diff --git a/assembly/features/org.eclipse.jsf.assembly.feature/.cvsignore b/assembly/features/org.eclipse.jsf.assembly.feature/.cvsignore
deleted file mode 100644
index 49d8479..0000000
--- a/assembly/features/org.eclipse.jsf.assembly.feature/.cvsignore
+++ /dev/null
@@ -1,3 +0,0 @@
-*.bin.dist.zip
-build.xml
-feature.temp.folder
diff --git a/assembly/features/org.eclipse.jsf.assembly.feature/.project b/assembly/features/org.eclipse.jsf.assembly.feature/.project
deleted file mode 100644
index 5adb9e2..0000000
--- a/assembly/features/org.eclipse.jsf.assembly.feature/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jsf.assembly.feature</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.FeatureBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.FeatureNature</nature>
-	</natures>
-</projectDescription>
diff --git a/assembly/features/org.eclipse.jsf.assembly.feature/.settings/org.eclipse.core.resources.prefs b/assembly/features/org.eclipse.jsf.assembly.feature/.settings/org.eclipse.core.resources.prefs
deleted file mode 100644
index fa491bf..0000000
--- a/assembly/features/org.eclipse.jsf.assembly.feature/.settings/org.eclipse.core.resources.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Sun May 27 16:00:47 EDT 2007
-eclipse.preferences.version=1
-encoding/<project>=ISO-8859-1
diff --git a/assembly/features/org.eclipse.jsf.assembly.feature/build.properties b/assembly/features/org.eclipse.jsf.assembly.feature/build.properties
deleted file mode 100644
index 8b13789..0000000
--- a/assembly/features/org.eclipse.jsf.assembly.feature/build.properties
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/assembly/features/org.eclipse.jsf.assembly.feature/eclipse_update_120.jpg b/assembly/features/org.eclipse.jsf.assembly.feature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/assembly/features/org.eclipse.jsf.assembly.feature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/assembly/features/org.eclipse.jsf.assembly.feature/feature.properties b/assembly/features/org.eclipse.jsf.assembly.feature/feature.properties
deleted file mode 100644
index 1c7a24b..0000000
--- a/assembly/features/org.eclipse.jsf.assembly.feature/feature.properties
+++ /dev/null
@@ -1,29 +0,0 @@
-###############################################################################
-# Copyright (c) 2005 Oracle Corporation.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-name=JavaServer Faces Tools (JSF) Project
-provider=Eclipse Web Tools Platform
-description=WTP JavaServer Faces Tools (JSF) Project 
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2006 Oracle Corporation.\
-All rights reserved. This program and the accompanying materials\
-are made available under the terms of the Eclipse Public License v1.0\
-which accompanies this distribution, and is available at\
-http://www.eclipse.org/legal/epl-v10.html\
-\n\
-Contributors:\n\
-    Oracle Corporation - initial API and implementation\n
-################ end of copyright property ####################################
-
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism. 
-########### end of license property ##########################################
diff --git a/assembly/features/org.eclipse.jsf.assembly.feature/feature.xml b/assembly/features/org.eclipse.jsf.assembly.feature/feature.xml
deleted file mode 100644
index 36b968e..0000000
--- a/assembly/features/org.eclipse.jsf.assembly.feature/feature.xml
+++ /dev/null
@@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jsf.assembly.feature"
-      label="%name"
-      version="3.2.2.qualifier"
-      provider-name="%provider"
-      plugin="org.eclipse.jsf.branding"
-      license-feature="org.eclipse.license"
-      license-feature-version="1.0.0.qualifier">
-
-   <description>
-      %description
-   </description>
-
-   <copyright>
-      %copyright
-   </copyright>
-
-   <license url="license.html">
-      %license
-   </license>
-
-   <includes
-         id="org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature"
-         version="0.0.0"/>
-
-   <includes
-         id="org.eclipse.jst.webpageeditor.feature"
-         version="0.0.0"/>
-
-   <includes
-         id="org.eclipse.jsf.feature"
-         version="0.0.0"/>
-
-</feature>
diff --git a/assembly/features/org.eclipse.jsf_sdk.assembly.feature/.cvsignore b/assembly/features/org.eclipse.jsf_sdk.assembly.feature/.cvsignore
deleted file mode 100644
index bc2abf7..0000000
--- a/assembly/features/org.eclipse.jsf_sdk.assembly.feature/.cvsignore
+++ /dev/null
@@ -1,4 +0,0 @@
-*.bin.dist.zip
-build.xml
-features
-plugins
diff --git a/assembly/features/org.eclipse.jsf_sdk.assembly.feature/.project b/assembly/features/org.eclipse.jsf_sdk.assembly.feature/.project
deleted file mode 100644
index 8a30754..0000000
--- a/assembly/features/org.eclipse.jsf_sdk.assembly.feature/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jsf_sdk.assembly.feature</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.FeatureBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.FeatureNature</nature>
-	</natures>
-</projectDescription>
diff --git a/assembly/features/org.eclipse.jsf_sdk.assembly.feature/build.properties b/assembly/features/org.eclipse.jsf_sdk.assembly.feature/build.properties
deleted file mode 100644
index e69de29..0000000
--- a/assembly/features/org.eclipse.jsf_sdk.assembly.feature/build.properties
+++ /dev/null
diff --git a/assembly/features/org.eclipse.jsf_sdk.assembly.feature/eclipse_update_120.jpg b/assembly/features/org.eclipse.jsf_sdk.assembly.feature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/assembly/features/org.eclipse.jsf_sdk.assembly.feature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/assembly/features/org.eclipse.jsf_sdk.assembly.feature/feature.properties b/assembly/features/org.eclipse.jsf_sdk.assembly.feature/feature.properties
deleted file mode 100644
index 9a083a4..0000000
--- a/assembly/features/org.eclipse.jsf_sdk.assembly.feature/feature.properties
+++ /dev/null
@@ -1,38 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle. - initial API and implementation
-###############################################################################
-name=JavaServer Faces Tools (JSF) Project SDK
-provider=Eclipse Web Tools Platform
-description=WTP JavaServer Faces Tools (JSF) Project  SDK
-
-
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2006 Oracle Corporation.\n\
-All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
-which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
-\n\
-Contributors:\n\
-    Oracle - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism. 
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism. 
-########### end of license property ##########################################
diff --git a/assembly/features/org.eclipse.jsf_sdk.assembly.feature/feature.xml b/assembly/features/org.eclipse.jsf_sdk.assembly.feature/feature.xml
deleted file mode 100644
index f760d9c..0000000
--- a/assembly/features/org.eclipse.jsf_sdk.assembly.feature/feature.xml
+++ /dev/null
@@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jsf_sdk.assembly.feature"
-      label="%featureName"
-      version="3.2.2.qualifier"
-      provider-name="%providerName"
-      image="eclipse_update_120.jpg"
-      license-feature="org.eclipse.license"
-      license-feature-version="1.0.0.qualifier">
-
-   <description>
-      %description
-   </description>
-
-   <copyright>
-      %copyright
-   </copyright>
-
-   <license url="license.html">
-      %license
-   </license>
-
-   <includes
-         id="org.eclipse.jst.jsf.apache.trinidad.tagsupport_sdk.feature"
-         version="0.0.0"/>
-
-   <includes
-         id="org.eclipse.jst.webpageeditor_sdk.feature"
-         version="0.0.0"/>
-
-   <includes
-         id="org.eclipse.jsf_sdk.feature"
-         version="0.0.0"/>
-
-</feature>
diff --git a/assembly/plugins/org.eclipse.jsf.branding/.cvsignore b/assembly/plugins/org.eclipse.jsf.branding/.cvsignore
deleted file mode 100644
index 7033a79..0000000
--- a/assembly/plugins/org.eclipse.jsf.branding/.cvsignore
+++ /dev/null
@@ -1,4 +0,0 @@
-bin
-@dot*
-temp.folder
-build.xml
diff --git a/assembly/plugins/org.eclipse.jsf.branding/.project b/assembly/plugins/org.eclipse.jsf.branding/.project
deleted file mode 100644
index c1c23a4..0000000
--- a/assembly/plugins/org.eclipse.jsf.branding/.project
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jsf.branding</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<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>
-	</natures>
-</projectDescription>
diff --git a/assembly/plugins/org.eclipse.jsf.branding/META-INF/MANIFEST.MF b/assembly/plugins/org.eclipse.jsf.branding/META-INF/MANIFEST.MF
deleted file mode 100644
index b295675..0000000
--- a/assembly/plugins/org.eclipse.jsf.branding/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,7 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: %plugin.Name
-Bundle-SymbolicName: org.eclipse.jsf.branding
-Bundle-Version: 3.2.0.qualifier
-Bundle-Localization: plugin
-Bundle-Vendor: %plugin.Provider
diff --git a/assembly/plugins/org.eclipse.jsf.branding/about.html b/assembly/plugins/org.eclipse.jsf.branding/about.html
deleted file mode 100644
index 7c80c6c..0000000
--- a/assembly/plugins/org.eclipse.jsf.branding/about.html
+++ /dev/null
@@ -1,22 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-<body lang="EN-US">
-<h2>About This Content</h2>
- 
-<p>June 06, 2007</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 1.0 (&quot;EPL&quot;).  A copy of the EPL is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</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.</p>
-
-</body>
-</html>
\ No newline at end of file
diff --git a/assembly/plugins/org.eclipse.jsf.branding/about.ini b/assembly/plugins/org.eclipse.jsf.branding/about.ini
deleted file mode 100644
index 0aac4fb..0000000
--- a/assembly/plugins/org.eclipse.jsf.branding/about.ini
+++ /dev/null
@@ -1,40 +0,0 @@
-###############################################################################
-# Copyright (c) 2006, 2009 Oracle.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation. - initial API and implementation
-###############################################################################
-
-# about.ini
-# contains information about a feature
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# "%key" are externalized strings defined in about.properties
-# This file does not need to be translated.
-
-# Property "aboutText" contains blurb for "About" dialog (translated)
-aboutText=%blurb
-
-# Property "windowImage" contains path to window icon (16x16)
-# needed for primary features only
-
-# Property "featureImage" contains path to feature image (32x32)
-featureImage=icons/WTP_icon_x32_v2.png
-
-# Property "aboutImage" contains path to product image (500x330 or 115x164)
-# needed for primary features only
-
-# Property "appName" contains name of the application (translated)
-# needed for primary features only
-
-# Property "welcomePage" contains path to welcome page (special XML-based format)
-# optional
-
-# Property "welcomePerspective" contains the id of the perspective in which the
-# welcome page is to be opened.
-# optional
-
-
diff --git a/assembly/plugins/org.eclipse.jsf.branding/about.mappings b/assembly/plugins/org.eclipse.jsf.branding/about.mappings
deleted file mode 100644
index bddaab4..0000000
--- a/assembly/plugins/org.eclipse.jsf.branding/about.mappings
+++ /dev/null
@@ -1,6 +0,0 @@
-# about.mappings
-# contains fill-ins for about.properties
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file does not need to be translated.
-
-0=@build@
\ No newline at end of file
diff --git a/assembly/plugins/org.eclipse.jsf.branding/about.properties b/assembly/plugins/org.eclipse.jsf.branding/about.properties
deleted file mode 100644
index 9e7f778..0000000
--- a/assembly/plugins/org.eclipse.jsf.branding/about.properties
+++ /dev/null
@@ -1,24 +0,0 @@
-###############################################################################
-# Copyright (c) 2005 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-
-# about.properties
-# contains externalized strings for about.ini
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# fill-ins are supplied by about.mappings
-# This file should be translated.
-
-blurb=JavaServer Faces Tools\n\
-\n\
-Version: {featureVersion}\n\
-Build id: {0}\n\
-\n\
-(c) Copyright Oracle contributors and others 2006, 2009.  All rights reserved.\n\
-Visit http://www.eclipse.org/webtools
diff --git a/assembly/plugins/org.eclipse.jsf.branding/build.properties b/assembly/plugins/org.eclipse.jsf.branding/build.properties
deleted file mode 100644
index 094e1ae..0000000
--- a/assembly/plugins/org.eclipse.jsf.branding/build.properties
+++ /dev/null
@@ -1,20 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2006 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-bin.includes = META-INF/,\
-               eclipse32.png,\
-               eclipse32.gif,\
-               about.properties,\
-               about.mappings,\
-               about.ini,\
-               about.html,\
-               plugin.properties,\
-               icons/WTP_icon_x32_v2.png
-
diff --git a/assembly/plugins/org.eclipse.jsf.branding/eclipse32.gif b/assembly/plugins/org.eclipse.jsf.branding/eclipse32.gif
deleted file mode 100644
index e6ad7cc..0000000
--- a/assembly/plugins/org.eclipse.jsf.branding/eclipse32.gif
+++ /dev/null
Binary files differ
diff --git a/assembly/plugins/org.eclipse.jsf.branding/eclipse32.png b/assembly/plugins/org.eclipse.jsf.branding/eclipse32.png
deleted file mode 100644
index 568fac1..0000000
--- a/assembly/plugins/org.eclipse.jsf.branding/eclipse32.png
+++ /dev/null
Binary files differ
diff --git a/assembly/plugins/org.eclipse.jsf.branding/icons/WTP_icon_x32_v2.png b/assembly/plugins/org.eclipse.jsf.branding/icons/WTP_icon_x32_v2.png
deleted file mode 100644
index 6f09c2a..0000000
--- a/assembly/plugins/org.eclipse.jsf.branding/icons/WTP_icon_x32_v2.png
+++ /dev/null
Binary files differ
diff --git a/assembly/plugins/org.eclipse.jsf.branding/plugin.properties b/assembly/plugins/org.eclipse.jsf.branding/plugin.properties
deleted file mode 100644
index 2b7a864..0000000
--- a/assembly/plugins/org.eclipse.jsf.branding/plugin.properties
+++ /dev/null
@@ -1,13 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-# Contributors:
-# IBM Corporation - initial API and implementation
-###############################################################################
-
-plugin.Name=JavaServer Faces Tools
-plugin.Provider=Eclipse.org
\ No newline at end of file
diff --git a/jsf/features/org.eclipse.jsf.feature/.cvsignore b/jsf/features/org.eclipse.jsf.feature/.cvsignore
deleted file mode 100644
index dafb923..0000000
--- a/jsf/features/org.eclipse.jsf.feature/.cvsignore
+++ /dev/null
@@ -1,4 +0,0 @@
-build.xml
-*bin.dist.zip
-org.eclipse.jst.jsf.feature*.jar
-feature.temp.folder
diff --git a/jsf/features/org.eclipse.jsf.feature/.project b/jsf/features/org.eclipse.jsf.feature/.project
deleted file mode 100644
index dff7881..0000000
--- a/jsf/features/org.eclipse.jsf.feature/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jsf.feature</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.FeatureBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.FeatureNature</nature>
-	</natures>
-</projectDescription>
diff --git a/jsf/features/org.eclipse.jsf.feature/.settings/org.eclipse.core.resources.prefs b/jsf/features/org.eclipse.jsf.feature/.settings/org.eclipse.core.resources.prefs
deleted file mode 100644
index 9a9e24d..0000000
--- a/jsf/features/org.eclipse.jsf.feature/.settings/org.eclipse.core.resources.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Sun May 27 16:03:41 EDT 2007
-eclipse.preferences.version=1
-encoding/<project>=ISO-8859-1
diff --git a/jsf/features/org.eclipse.jsf.feature/build.properties b/jsf/features/org.eclipse.jsf.feature/build.properties
deleted file mode 100644
index 97426d9..0000000
--- a/jsf/features/org.eclipse.jsf.feature/build.properties
+++ /dev/null
@@ -1,13 +0,0 @@
-###############################################################################
-# Copyright (c) 2005 Oracle Corporation.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-# Contributors:
-#    Gerry Kessler - initial API and implementation
-###############################################################################
-bin.includes = feature.xml,\
-               feature.properties,\
-               eclipse_update_120.jpg
diff --git a/jsf/features/org.eclipse.jsf.feature/eclipse_update_120.jpg b/jsf/features/org.eclipse.jsf.feature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jsf/features/org.eclipse.jsf.feature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jsf.feature/feature.properties b/jsf/features/org.eclipse.jsf.feature/feature.properties
deleted file mode 100644
index 492dddc..0000000
--- a/jsf/features/org.eclipse.jsf.feature/feature.properties
+++ /dev/null
@@ -1,31 +0,0 @@
-###############################################################################
-# Copyright (c) 2005, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-name=JavaServer Faces Tools (JSF) Project
-provider=Eclipse Web Tools Platform
-description=WTP JavaServer Faces Tools (JSF) Project 
-updateSiteName=The Eclipse Web Tools Platform (WTP) Project update site
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism. 
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2006 Oracle Corporation.\
-All rights reserved. This program and the accompanying materials\
-are made available under the terms of the Eclipse Public License v1.0\
-which accompanies this distribution, and is available at\
-http://www.eclipse.org/legal/epl-v10.html\
-\n\
-Contributors:\n\
-    Oracle Corporation - initial API and implementation\n
-################ end of copyright property ####################################
-
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism. 
-########### end of license property ##########################################
diff --git a/jsf/features/org.eclipse.jsf.feature/feature.xml b/jsf/features/org.eclipse.jsf.feature/feature.xml
deleted file mode 100644
index 2def8b8..0000000
--- a/jsf/features/org.eclipse.jsf.feature/feature.xml
+++ /dev/null
@@ -1,100 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jsf.feature"
-      label="%name"
-      version="3.3.0.qualifier"
-      provider-name="%provider"
-      image="eclipse_update_120.jpg"
-      license-feature="org.eclipse.license"
-      license-feature-version="1.0.0.qualifier">
-
-   <description>
-      %description
-   </description>
-
-   <copyright>
-      %copyright
-   </copyright>
-
-   <license url="license.html">
-      %license
-   </license>
-
-   <plugin
-         id="org.eclipse.jst.jsf.common"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jst.jsf.common.runtime"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jst.jsf.common.ui"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jst.jsf.core"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jst.jsf.facelet.core"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jst.jsf.facelet.ui"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jst.jsf.facesconfig"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jst.jsf.facesconfig.ui"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jst.jsf.ui"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jst.jsf.standard.tagsupport"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jsf.branding"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-</feature>
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/about.html b/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/about.html
deleted file mode 100644
index fe81d46..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/about.html
+++ /dev/null
@@ -1,27 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-<body lang="EN-US">
-<h2>About This Content</h2>
-
-<P>June, 2008</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 1.0 (&quot;EPL&quot;).  A copy of the EPL is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</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.</p>
-
-<h3>Source Code</h3>
-<p>This plug-in contains source code zip files (&quot;Source Zips&quot;) that correspond to binary content in other plug-ins. These Source Zips may be distributed under different license
-agreements and/or notices. Details about these license agreements and notices are contained in &quot;about.html&quot; files (&quot;Abouts&quot;) located in sub-directories in the
-src/ directory of this plug-in. Such Abouts govern your use of the Source Zips in that directory, not the EPL.</p>
-
-</body>
-</html>
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/about.ini b/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/about.ini
deleted file mode 100644
index 2dee36a..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/about.ini
+++ /dev/null
@@ -1,31 +0,0 @@
-# about.ini
-# contains information about a feature
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# "%key" are externalized strings defined in about.properties
-# This file does not need to be translated.
-
-# Property "aboutText" contains blurb for "About" dialog (translated)
-aboutText=%blurb
-
-# Property "windowImage" contains path to window icon (16x16)
-# needed for primary features only
-
-# Property "featureImage" contains path to feature image (32x32)
-featureImage=eclipse32.gif
-
-# Property "aboutImage" contains path to product image (500x330 or 115x164)
-# needed for primary features only
-
-# Property "appName" contains name of the application (not translated)
-# needed for primary features only
-
-# Property "welcomePage" contains path to welcome page (special XML-based format)
-# optional
-
-# Property "welcomePerspective" contains the id of the perspective in which the
-# welcome page is to be opened.
-# optional
-
-
-
-
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/about.mappings b/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/about.mappings
deleted file mode 100644
index a28390a..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/about.mappings
+++ /dev/null
@@ -1,6 +0,0 @@
-# about.mappings
-# contains fill-ins for about.properties
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file does not need to be translated.
-
-0=@build@
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/about.properties b/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/about.properties
deleted file mode 100644
index 4e33f86..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/about.properties
+++ /dev/null
@@ -1,26 +0,0 @@
-###############################################################################
-# Copyright (c) 2005, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-# about.properties
-# contains externalized strings for about.ini
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# fill-ins are supplied by about.mappings
-# This file should be translated.
-#
-# Do not translate any values surrounded by {}
-
-blurb=JavaServer Faces Tools Source\n\
-\n\
-Version: {featureVersion}\n\
-Build id: {0}\n\
-\n\
-(c) Copyright Eclipse contributors and others 2005.  All rights reserved.\n\
-Visit http://www.eclipse.org/webtools
-
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/build.properties b/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/build.properties
deleted file mode 100644
index 43309f0..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/build.properties
+++ /dev/null
@@ -1,13 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-
-bin.includes = about.html, about.ini, about.mappings, about.properties, eclipse32.gif, plugin.properties, plugin.xml, src/**, META-INF/
-sourcePlugin = true
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/eclipse32.gif b/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/eclipse32.gif
deleted file mode 100644
index e6ad7cc..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/eclipse32.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/eclipse32.png b/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/eclipse32.png
deleted file mode 100644
index 50ae49d..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/eclipse32.png
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/eclipse_update_120.jpg b/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/epl-v10.html b/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/epl-v10.html
deleted file mode 100644
index 022ad29..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/license.html b/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/license.html
deleted file mode 100644
index 14b1d50..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/license.html
+++ /dev/null
@@ -1,83 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<title>Eclipse.org Software User Agreement</title>
-</head>
-
-<body lang="EN-US" link=blue vlink=purple>
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>June 06, 2007</p>
-
-<h3>Usage Of Content</h3>
-
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY &quot;CONTENT&quot;).  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
-   
-<h3>Applicable Licenses</h3>   
-   
-<p>Unless otherwise indicated, all Content made available by the Eclipse Foundation is provided to you under the terms and conditions of the Eclipse Public License Version 1.0
-   (&quot;EPL&quot;).  A copy of the EPL is provided with this Content and is also available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
-
-<p>Content includes, but is not limited to, source code, object code, documentation and other files maintained in the Eclipse.org CVS repository (&quot;Repository&quot;) in CVS
-   modules (&quot;Modules&quot;) and made available as downloadable archives (&quot;Downloads&quot;).</p>
-   
-<ul>
-	<li>Content may be structured and packaged into modules to facilitate delivering, extending, and upgrading the Content.  Typical modules may include plug-ins (&quot;Plug-ins&quot;), plug-in fragments (&quot;Fragments&quot;), and features (&quot;Features&quot;).</li>
-	<li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&trade; ARchive) in a directory named &quot;plugins&quot;.</li>
-	<li>A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.  Each Feature may be packaged as a sub-directory in a directory named &quot;features&quot;.  Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-	<li>Features may also include other Features (&quot;Included Features&quot;). Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of Included Features.</li>
-</ul>   
- 
-<p>The terms and conditions governing Plug-ins and Fragments should be contained in files named &quot;about.html&quot; (&quot;Abouts&quot;). The terms and conditions governing Features and
-Included Features should be contained in files named &quot;license.html&quot; (&quot;Feature Licenses&quot;).  Abouts and Feature Licenses may be located in any directory of a Download or Module
-including, but not limited to the following locations:</p>
-
-<ul>
-	<li>The top-level (root) directory</li>
-	<li>Plug-in and Fragment directories</li>
-	<li>Inside Plug-ins and Fragments packaged as JARs</li>
-	<li>Sub-directories of the directory named &quot;src&quot; of certain Plug-ins</li>
-	<li>Feature directories</li>
-</ul>
-		
-<p>Note: if a Feature made available by the Eclipse Foundation is installed using the Eclipse Update Manager, you must agree to a license (&quot;Feature Update License&quot;) during the
-installation process.  If the Feature contains Included Features, the Feature Update License should either provide you with the terms and conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be found in the &quot;license&quot; property of files named &quot;feature.properties&quot; found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the terms and conditions (or references to such terms and conditions) that govern your use of the associated Content in
-that directory.</p>
-
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
-
-<ul>
-	<li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-	<li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-	<li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-	<li>IBM Public License 1.0 (available at <a href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</a>)</li>	
-	<li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-	<li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-  
-  <LI>Common Development and Distribution License (CDDL) Version 1.0 (available at <A 
-  href="http://www.sun.com/cddl/cddl.html">http://www.sun.com/cddl/cddl.html)</A>
-  </LI>
-</UL>
-
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions govern that particular Content.</p>
-
-<h3>Cryptography</h3>
-
-<p>Content may contain encryption software. The country in which you are currently may have restrictions on the import, possession, and use, and/or re-export to
-   another country, of encryption software. BEFORE using any encryption software, please check the country's laws, regulations and policies concerning the import,
-   possession, or use, and re-export of encryption software, to see if this is permitted.</p>
-   
-<small>Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.</small>   
-</body>
-</html>
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/plugin.properties b/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/plugin.properties
deleted file mode 100644
index 1c402d4..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplateBundle/plugin.properties
+++ /dev/null
@@ -1,12 +0,0 @@
-###############################################################################
-# Copyright (c) 2005, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-pluginName=JavaServer Faces Tools - Source
-providerName=Eclipse.org
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplateFeature/build.properties b/jsf/features/org.eclipse.jsf.feature/sourceTemplateFeature/build.properties
deleted file mode 100644
index f453452..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplateFeature/build.properties
+++ /dev/null
@@ -1,14 +0,0 @@
-###############################################################################
-# Copyright (c) 2000, 2005 IBM Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation- initial API and implementation
-###############################################################################
-bin.includes =\
-eclipse_update_120.jpg,\
-feature.xml,\
-feature.properties,\
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplateFeature/eclipse_update_120.jpg b/jsf/features/org.eclipse.jsf.feature/sourceTemplateFeature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplateFeature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplateFeature/feature.properties b/jsf/features/org.eclipse.jsf.feature/sourceTemplateFeature/feature.properties
deleted file mode 100644
index 27442d3..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplateFeature/feature.properties
+++ /dev/null
@@ -1,46 +0,0 @@
-###############################################################################
-# Copyright (c) 2006 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-# feature.properties
-# contains externalized strings for feature.xml
-# "%foo" in feature.xml corresponds to the key "foo" in this file
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file should be translated.
-
-# "featureName" property - name of the feature
-name=JavaServer Faces Tools (JSF) Project
-# "providerName" property - name of the company that provides the feature
-provider=Eclipse Web Tools Platform
-# "description" property - description of the feature
-description=WTP JavaServer Faces Tools (JSF) Project
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2006 Oracle Corporation.\
-All rights reserved. This program and the accompanying materials\
-are made available under the terms of the Eclipse Public License v1.0\
-which accompanies this distribution, and is available at\
-http://www.eclipse.org/legal/epl-v10.html\
-\n\
-Contributors:\n\
-    Oracle Corporation - initial API and implementation\n
-################ end of copyright property ####################################
-
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism. 
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism. 
-########### end of license property ##########################################
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/about.html b/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/about.html
deleted file mode 100644
index e991479..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/about.html
+++ /dev/null
@@ -1,27 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-<body lang="EN-US">
-<h2>About This Content</h2>
-
-<p>June, 2008</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 1.0 (&quot;EPL&quot;).  A copy of the EPL is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</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.</p>
-
-<h3>Source Code</h3>
-<p>This plug-in contains source code zip files (&quot;Source Zips&quot;) that correspond to binary content in other plug-ins. These Source Zips may be distributed under different license
-agreements and/or notices. Details about these license agreements and notices are contained in &quot;about.html&quot; files (&quot;Abouts&quot;) located in sub-directories in the
-src/ directory of this plug-in. Such Abouts govern your use of the Source Zips in that directory, not the EPL.</p>
-
-</body>
-</html>
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/about.ini b/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/about.ini
deleted file mode 100644
index 2dee36a..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/about.ini
+++ /dev/null
@@ -1,31 +0,0 @@
-# about.ini
-# contains information about a feature
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# "%key" are externalized strings defined in about.properties
-# This file does not need to be translated.
-
-# Property "aboutText" contains blurb for "About" dialog (translated)
-aboutText=%blurb
-
-# Property "windowImage" contains path to window icon (16x16)
-# needed for primary features only
-
-# Property "featureImage" contains path to feature image (32x32)
-featureImage=eclipse32.gif
-
-# Property "aboutImage" contains path to product image (500x330 or 115x164)
-# needed for primary features only
-
-# Property "appName" contains name of the application (not translated)
-# needed for primary features only
-
-# Property "welcomePage" contains path to welcome page (special XML-based format)
-# optional
-
-# Property "welcomePerspective" contains the id of the perspective in which the
-# welcome page is to be opened.
-# optional
-
-
-
-
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/about.mappings b/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/about.mappings
deleted file mode 100644
index a28390a..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/about.mappings
+++ /dev/null
@@ -1,6 +0,0 @@
-# about.mappings
-# contains fill-ins for about.properties
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file does not need to be translated.
-
-0=@build@
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/about.properties b/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/about.properties
deleted file mode 100644
index 4e33f86..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/about.properties
+++ /dev/null
@@ -1,26 +0,0 @@
-###############################################################################
-# Copyright (c) 2005, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-# about.properties
-# contains externalized strings for about.ini
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# fill-ins are supplied by about.mappings
-# This file should be translated.
-#
-# Do not translate any values surrounded by {}
-
-blurb=JavaServer Faces Tools Source\n\
-\n\
-Version: {featureVersion}\n\
-Build id: {0}\n\
-\n\
-(c) Copyright Eclipse contributors and others 2005.  All rights reserved.\n\
-Visit http://www.eclipse.org/webtools
-
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/build.properties b/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/build.properties
deleted file mode 100644
index 05582e3..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/build.properties
+++ /dev/null
@@ -1,12 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-bin.includes = about.html, about.ini, about.mappings, about.properties, eclipse32.gif, plugin.properties, plugin.xml, src/**, META-INF/
-sourcePlugin = true
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/eclipse32.gif b/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/eclipse32.gif
deleted file mode 100644
index e6ad7cc..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/eclipse32.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/eclipse32.png b/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/eclipse32.png
deleted file mode 100644
index 50ae49d..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/eclipse32.png
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/eclipse_update_120.jpg b/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/epl-v10.html b/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/epl-v10.html
deleted file mode 100644
index 022ad29..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/epl-v10.html
+++ /dev/null
@@ -1,328 +0,0 @@
-<html xmlns:o="urn:schemas-microsoft-com:office:office"
-xmlns:w="urn:schemas-microsoft-com:office:word"
-xmlns="http://www.w3.org/TR/REC-html40">
-
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
-<meta name=ProgId content=Word.Document>
-<meta name=Generator content="Microsoft Word 9">
-<meta name=Originator content="Microsoft Word 9">
-<link rel=File-List
-href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
-<title>Eclipse Public License - Version 1.0</title>
-<!--[if gte mso 9]><xml>
- <o:DocumentProperties>
-  <o:Revision>2</o:Revision>
-  <o:TotalTime>3</o:TotalTime>
-  <o:Created>2004-03-05T23:03:00Z</o:Created>
-  <o:LastSaved>2004-03-05T23:03:00Z</o:LastSaved>
-  <o:Pages>4</o:Pages>
-  <o:Words>1626</o:Words>
-  <o:Characters>9270</o:Characters>
-   <o:Lines>77</o:Lines>
-  <o:Paragraphs>18</o:Paragraphs>
-  <o:CharactersWithSpaces>11384</o:CharactersWithSpaces>
-  <o:Version>9.4402</o:Version>
- </o:DocumentProperties>
-</xml><![endif]--><!--[if gte mso 9]><xml>
- <w:WordDocument>
-  <w:TrackRevisions/>
- </w:WordDocument>
-</xml><![endif]-->
-<style>
-<!--
- /* Font Definitions */
-@font-face
-	{font-family:Tahoma;
-	panose-1:2 11 6 4 3 5 4 4 2 4;
-	mso-font-charset:0;
-	mso-generic-font-family:swiss;
-	mso-font-pitch:variable;
-	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
- /* Style Definitions */
-p.MsoNormal, li.MsoNormal, div.MsoNormal
-	{mso-style-parent:"";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p
-	{margin-right:0in;
-	mso-margin-top-alt:auto;
-	mso-margin-bottom-alt:auto;
-	margin-left:0in;
-	mso-pagination:widow-orphan;
-	font-size:12.0pt;
-	font-family:"Times New Roman";
-	mso-fareast-font-family:"Times New Roman";}
-p.BalloonText, li.BalloonText, div.BalloonText
-	{mso-style-name:"Balloon Text";
-	margin:0in;
-	margin-bottom:.0001pt;
-	mso-pagination:widow-orphan;
-	font-size:8.0pt;
-	font-family:Tahoma;
-	mso-fareast-font-family:"Times New Roman";}
-@page Section1
-	{size:8.5in 11.0in;
-	margin:1.0in 1.25in 1.0in 1.25in;
-	mso-header-margin:.5in;
-	mso-footer-margin:.5in;
-	mso-paper-source:0;}
-div.Section1
-	{page:Section1;}
--->
-</style>
-</head>
-
-<body lang=EN-US style='tab-interval:.5in'>
-
-<div class=Section1>
-
-<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
-</p>
-
-<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
-THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
-REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
-OF THIS AGREEMENT.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-in the case of the initial Contributor, the initial code and documentation
-distributed under this Agreement, and<br clear=left>
-b) in the case of each subsequent Contributor:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-changes to the Program, and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-additions to the Program;</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
-such changes and/or additions to the Program originate from and are distributed
-by that particular Contributor. A Contribution 'originates' from a Contributor
-if it was added to the Program by such Contributor itself or anyone acting on
-such Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in conjunction
-with the Program under their own license agreement, and (ii) are not derivative
-works of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
-entity that distributes the Program.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
-claims licensable by a Contributor which are necessarily infringed by the use
-or sale of its Contribution alone or when combined with the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
-distributed in accordance with this Agreement.</span> </p>
-
-<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
-receives the Program under this Agreement, including all Contributors.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-Subject to the terms of this Agreement, each Contributor hereby grants Recipient
-a non-exclusive, worldwide, royalty-free copyright license to<span
-style='color:red'> </span>reproduce, prepare derivative works of, publicly
-display, publicly perform, distribute and sublicense the Contribution of such
-Contributor, if any, and such derivative works, in source code and object code
-form.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-Subject to the terms of this Agreement, each Contributor hereby grants
-Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
-patent license under Licensed Patents to make, use, sell, offer to sell, import
-and otherwise transfer the Contribution of such Contributor, if any, in source
-code and object code form. This patent license shall apply to the combination
-of the Contribution and the Program if, at the time the Contribution is added
-by the Contributor, such addition of the Contribution causes such combination
-to be covered by the Licensed Patents. The patent license shall not apply to
-any other combinations which include the Contribution. No hardware per se is
-licensed hereunder. </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
-Recipient understands that although each Contributor grants the licenses to its
-Contributions set forth herein, no assurances are provided by any Contributor
-that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient
-for claims brought by any other entity based on infringement of intellectual
-property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility
-to secure any other intellectual property rights needed, if any. For example,
-if a third party patent license is required to allow Recipient to distribute
-the Program, it is Recipient's responsibility to acquire that license before
-distributing the Program.</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
-Each Contributor represents that to its knowledge it has sufficient copyright
-rights in its Contribution, if any, to grant the copyright license set forth in
-this Agreement. </span></p>
-
-<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
-
-<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
-Program in object code form under its own license agreement, provided that:</span>
-</p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it complies with the terms and conditions of this Agreement; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
-its license agreement:</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
-effectively disclaims on behalf of all Contributors all warranties and
-conditions, express and implied, including warranties or conditions of title
-and non-infringement, and implied warranties or conditions of merchantability
-and fitness for a particular purpose; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
-effectively excludes on behalf of all Contributors all liability for damages,
-including direct, indirect, special, incidental and consequential damages, such
-as lost profits; </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
-states that any provisions which differ from this Agreement are offered by that
-Contributor alone and not by any other party; and</span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
-states that source code for the Program is available from such Contributor, and
-informs licensees how to obtain it in a reasonable manner on or through a
-medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
-
-<p><span style='font-size:10.0pt'>When the Program is made available in source
-code form:</span> </p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
-it must be made available under this Agreement; and </span></p>
-
-<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
-copy of this Agreement must be included with each copy of the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
-copyright notices contained within the Program. </span></p>
-
-<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
-originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution. </span></p>
-
-<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
-
-<p><span style='font-size:10.0pt'>Commercial distributors of software may
-accept certain responsibilities with respect to end users, business partners
-and the like. While this license is intended to facilitate the commercial use
-of the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create potential
-liability for other Contributors. Therefore, if a Contributor includes the
-Program in a commercial product offering, such Contributor (&quot;Commercial
-Contributor&quot;) hereby agrees to defend and indemnify every other
-Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
-costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
-legal actions brought by a third party against the Indemnified Contributor to
-the extent caused by the acts or omissions of such Commercial Contributor in
-connection with its distribution of the Program in a commercial product
-offering. The obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In order
-to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor
-to control, and cooperate with the Commercial Contributor in, the defense and
-any related settlement negotiations. The Indemnified Contributor may participate
-in any such claim at its own expense.</span> </p>
-
-<p><span style='font-size:10.0pt'>For example, a Contributor might include the
-Program in a commercial product offering, Product X. That Contributor is then a
-Commercial Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance claims and
-warranties are such Commercial Contributor's responsibility alone. Under this
-section, the Commercial Contributor would have to defend claims against the
-other Contributors related to those performance claims and warranties, and if a
-court requires any other Contributor to pay any damages as a result, the
-Commercial Contributor must pay those damages.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
-WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and distributing the
-Program and assumes all risks associated with its exercise of rights under this
-Agreement , including but not limited to the risks and costs of program errors,
-compliance with applicable laws, damage to or loss of data, programs or
-equipment, and unavailability or interruption of operations. </span></p>
-
-<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
-
-<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
-AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
-THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
-
-<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
-
-<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
-or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without
-further action by the parties hereto, such provision shall be reformed to the
-minimum extent necessary to make such provision valid and enforceable.</span> </p>
-
-<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
-against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with
-other software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the date
-such litigation is filed. </span></p>
-
-<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
-shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable
-period of time after becoming aware of such noncompliance. If all Recipient's
-rights under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive. </span></p>
-
-<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
-copies of this Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The Agreement
-Steward reserves the right to publish new versions (including revisions) of
-this Agreement from time to time. No one other than the Agreement Steward has
-the right to modify this Agreement. The Eclipse Foundation is the initial
-Agreement Steward. The Eclipse Foundation may assign the responsibility to
-serve as the Agreement Steward to a suitable separate entity. Each new version
-of the Agreement will be given a distinguishing version number. The Program
-(including Contributions) may always be distributed subject to the version of
-the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program
-(including its Contributions) under the new version. Except as expressly stated
-in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether
-expressly, by implication, estoppel or otherwise. All rights in the Program not
-expressly granted under this Agreement are reserved.</span> </p>
-
-<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
-State of New York and the intellectual property laws of the United States of
-America. No party to this Agreement will bring a legal action under this
-Agreement more than one year after the cause of action arose. Each party waives
-its rights to a jury trial in any resulting litigation.</span> </p>
-
-<p class=MsoNormal><![if !supportEmptyParas]>&nbsp;<![endif]><o:p></o:p></p>
-
-</div>
-
-</body>
-
-</html>
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/license.html b/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/license.html
deleted file mode 100644
index fec4a48..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/license.html
+++ /dev/null
@@ -1,82 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<meta http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<title>Eclipse.org Software User Agreement</title>
-</head>
-
-<body lang="EN-US" link=blue vlink=purple>
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>June 06, 2007</p>
-
-<h3>Usage Of Content</h3>
-
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY &quot;CONTENT&quot;).  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
-   
-<h3>Applicable Licenses</h3>   
-   
-<p>Unless otherwise indicated, all Content made available by the Eclipse Foundation is provided to you under the terms and conditions of the Eclipse Public License Version 1.0
-   (&quot;EPL&quot;).  A copy of the EPL is provided with this Content and is also available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
-
-<p>Content includes, but is not limited to, source code, object code, documentation and other files maintained in the Eclipse.org CVS repository (&quot;Repository&quot;) in CVS
-   modules (&quot;Modules&quot;) and made available as downloadable archives (&quot;Downloads&quot;).</p>
-   
-<ul>
-	<li>Content may be structured and packaged into modules to facilitate delivering, extending, and upgrading the Content.  Typical modules may include plug-ins (&quot;Plug-ins&quot;), plug-in fragments (&quot;Fragments&quot;), and features (&quot;Features&quot;).</li>
-	<li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&trade; ARchive) in a directory named &quot;plugins&quot;.</li>
-	<li>A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.  Each Feature may be packaged as a sub-directory in a directory named &quot;features&quot;.  Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-	<li>Features may also include other Features (&quot;Included Features&quot;). Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of Included Features.</li>
-</ul>   
- 
-<p>The terms and conditions governing Plug-ins and Fragments should be contained in files named &quot;about.html&quot; (&quot;Abouts&quot;). The terms and conditions governing Features and
-Included Features should be contained in files named &quot;license.html&quot; (&quot;Feature Licenses&quot;).  Abouts and Feature Licenses may be located in any directory of a Download or Module
-including, but not limited to the following locations:</p>
-
-<ul>
-	<li>The top-level (root) directory</li>
-	<li>Plug-in and Fragment directories</li>
-	<li>Inside Plug-ins and Fragments packaged as JARs</li>
-	<li>Sub-directories of the directory named &quot;src&quot; of certain Plug-ins</li>
-	<li>Feature directories</li>
-</ul>
-		
-<p>Note: if a Feature made available by the Eclipse Foundation is installed using the Eclipse Update Manager, you must agree to a license (&quot;Feature Update License&quot;) during the
-installation process.  If the Feature contains Included Features, the Feature Update License should either provide you with the terms and conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be found in the &quot;license&quot; property of files named &quot;feature.properties&quot; found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the terms and conditions (or references to such terms and conditions) that govern your use of the associated Content in
-that directory.</p>
-
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
-
-<ul>
-	<li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-	<li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-	<li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-	<li>IBM Public License 1.0 (available at <a href="http://oss.software.ibm.com/developerworks/opensource/license10.html">http://oss.software.ibm.com/developerworks/opensource/license10.html</a>)</li>	
-	<li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-	<li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-  <LI>Common Development and Distribution License (CDDL) Version 1.0 (available at <A 
-  href="http://www.sun.com/cddl/cddl.html">http://www.sun.com/cddl/cddl.html)</A>
-  </LI>
-</UL>
-
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions govern that particular Content.</p>
-
-<h3>Cryptography</h3>
-
-<p>Content may contain encryption software. The country in which you are currently may have restrictions on the import, possession, and use, and/or re-export to
-   another country, of encryption software. BEFORE using any encryption software, please check the country's laws, regulations and policies concerning the import,
-   possession, or use, and re-export of encryption software, to see if this is permitted.</p>
-   
-<small>Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.</small>   
-</body>
-</html>
diff --git a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/plugin.properties b/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/plugin.properties
deleted file mode 100644
index 1c402d4..0000000
--- a/jsf/features/org.eclipse.jsf.feature/sourceTemplatePlugin/plugin.properties
+++ /dev/null
@@ -1,12 +0,0 @@
-###############################################################################
-# Copyright (c) 2005, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-pluginName=JavaServer Faces Tools - Source
-providerName=Eclipse.org
diff --git a/jsf/features/org.eclipse.jsf_sdk.feature/.project b/jsf/features/org.eclipse.jsf_sdk.feature/.project
deleted file mode 100644
index bf76782..0000000
--- a/jsf/features/org.eclipse.jsf_sdk.feature/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jsf_sdk.feature</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.FeatureBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.FeatureNature</nature>
-	</natures>
-</projectDescription>
diff --git a/jsf/features/org.eclipse.jsf_sdk.feature/.settings/org.eclipse.core.resources.prefs b/jsf/features/org.eclipse.jsf_sdk.feature/.settings/org.eclipse.core.resources.prefs
deleted file mode 100644
index fa491bf..0000000
--- a/jsf/features/org.eclipse.jsf_sdk.feature/.settings/org.eclipse.core.resources.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Sun May 27 16:00:47 EDT 2007
-eclipse.preferences.version=1
-encoding/<project>=ISO-8859-1
diff --git a/jsf/features/org.eclipse.jsf_sdk.feature/build.properties b/jsf/features/org.eclipse.jsf_sdk.feature/build.properties
deleted file mode 100644
index 9251080..0000000
--- a/jsf/features/org.eclipse.jsf_sdk.feature/build.properties
+++ /dev/null
@@ -1,16 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-bin.includes = feature.xml,\
-               feature.properties,\
-               eclipse_update_120.jpg
-               
-
-generate.feature@org.eclipse.jsf.feature.source=org.eclipse.jsf.feature
diff --git a/jsf/features/org.eclipse.jsf_sdk.feature/eclipse_update_120.jpg b/jsf/features/org.eclipse.jsf_sdk.feature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jsf/features/org.eclipse.jsf_sdk.feature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jsf_sdk.feature/feature.properties b/jsf/features/org.eclipse.jsf_sdk.feature/feature.properties
deleted file mode 100644
index 406330e..0000000
--- a/jsf/features/org.eclipse.jsf_sdk.feature/feature.properties
+++ /dev/null
@@ -1,41 +0,0 @@
-###############################################################################
-# Copyright (c) 2005, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-name=JavaServer Faces Tools (JSF) Project SDK
-provider=Eclipse Web Tools Platform
-description=WTP JavaServer Faces Tools (JSF) Project SDK
-
-# "updateSiteName" property - label for the update site
-updateSiteName=The Eclipse Web Tools Platform (WTP) Project update site
-
-# "description" property - description of the feature
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism. 
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2006 Oracle Corporation.\
-All rights reserved. This program and the accompanying materials\
-are made available under the terms of the Eclipse Public License v1.0\
-which accompanies this distribution, and is available at\
-http://www.eclipse.org/legal/epl-v10.html\
-\n\
-Contributors:\n\
-    Oracle Corporation - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism. 
-########### end of license property ##########################################
diff --git a/jsf/features/org.eclipse.jsf_sdk.feature/feature.xml b/jsf/features/org.eclipse.jsf_sdk.feature/feature.xml
deleted file mode 100644
index c55629f..0000000
--- a/jsf/features/org.eclipse.jsf_sdk.feature/feature.xml
+++ /dev/null
@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jsf_sdk.feature"
-      label="%name"
-      version="3.3.0.qualifier"
-      provider-name="%provider"
-      image="eclipse_update_120.jpg"
-      license-feature="org.eclipse.license"
-      license-feature-version="1.0.0.qualifier">
-
-   <description>
-      %description
-   </description>
-
-   <copyright>
-      %copyright
-   </copyright>
-
-   <license url="license.html">
-      %license
-   </license>
-
-   <includes
-         id="org.eclipse.jsf.feature"
-         version="0.0.0"/>
-
-   <includes
-         id="org.eclipse.jsf.feature.source"
-         version="0.0.0"/>
-
-</feature>
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/.cvsignore b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/.cvsignore
deleted file mode 100644
index c14487c..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/.cvsignore
+++ /dev/null
@@ -1 +0,0 @@
-build.xml
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/.project b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/.project
deleted file mode 100644
index a1d8502..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.FeatureBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.FeatureNature</nature>
-	</natures>
-</projectDescription>
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/build.properties b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/build.properties
deleted file mode 100644
index bd6dd1b..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/build.properties
+++ /dev/null
@@ -1,13 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2008 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-bin.includes = feature.xml,\
-               feature.properties,\
-               eclipse_update_120.jpg
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/eclipse_update_120.jpg b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/feature.properties b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/feature.properties
deleted file mode 100644
index 39426e3..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/feature.properties
+++ /dev/null
@@ -1,48 +0,0 @@
-###############################################################################
-# Copyright (c) 2005, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-# Contributors:
-#    Oracle Corporation - initial API and implementation
-###############################################################################
-# feature.properties
-# contains externalized strings for feature.xml
-# "%foo" in feature.xml corresponds to the key "foo" in this file
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file should be translated.
-
-# "featureName" property - name of the feature
-featureName=Apache MyFaces Trinidad Tag Support (Optional)
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse.org
-
-
-# "description" property - description of the feature
-description=Apache MyFaces Trinidad Tag Support (Optional)
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2007 Oracle Corporation.\
-All rights reserved. This program and the accompanying materials\
-are made available under the terms of the Eclipse Public License v1.0\
-which accompanies this distribution, and is available at\
-http://www.eclipse.org/legal/epl-v10.html\
-\n\
-Contributors:\n\
-    Oracle Corporation - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism. 
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism. 
-########### end of license property ##########################################
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/feature.xml b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/feature.xml
deleted file mode 100644
index 1dacc1f..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/feature.xml
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature"
-      label="%featureName"
-      version="2.2.200.qualifier"
-      provider-name="%providerName"
-      license-feature="org.eclipse.license"
-      license-feature-version="1.0.0.qualifier">
-
-   <description>
-      %description
-   </description>
-
-   <copyright>
-      %copyright
-   </copyright>
-
-   <license url="license.html">
-      %license
-   </license>
-
-   <requires>
-      <import plugin="org.eclipse.ui" version="3.2.0" match="compatible"/>
-      <import plugin="org.eclipse.core.runtime" version="3.2.0" match="compatible"/>
-      <import plugin="org.eclipse.emf.ecore.xmi" version="2.2.0" match="compatible"/>
-      <import plugin="org.eclipse.gef" version="3.2.0" match="compatible"/>
-      <import plugin="org.eclipse.wst.sse.core" version="1.1.0" match="equivalent"/>
-      <import plugin="org.eclipse.jst.jsf.common" version="1.1.0" match="compatible"/>
-      <import plugin="org.eclipse.jst.pagedesigner" version="1.1.0" match="compatible"/>
-      <import plugin="org.eclipse.jst.jsf.core" version="1.1.0" match="compatible"/>
-      <import plugin="org.eclipse.jdt.core" version="3.4.0" match="compatible"/>
-      <import plugin="org.eclipse.core.resources" version="3.4.0" match="compatible"/>
-   </requires>
-
-   <plugin
-         id="org.eclipse.jst.jsf.apache.trinidad.tagsupport"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-</feature>
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/about.html b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/about.html
deleted file mode 100644
index fe81d46..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/about.html
+++ /dev/null
@@ -1,27 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-<body lang="EN-US">
-<h2>About This Content</h2>
-
-<P>June, 2008</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 1.0 (&quot;EPL&quot;).  A copy of the EPL is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</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.</p>
-
-<h3>Source Code</h3>
-<p>This plug-in contains source code zip files (&quot;Source Zips&quot;) that correspond to binary content in other plug-ins. These Source Zips may be distributed under different license
-agreements and/or notices. Details about these license agreements and notices are contained in &quot;about.html&quot; files (&quot;Abouts&quot;) located in sub-directories in the
-src/ directory of this plug-in. Such Abouts govern your use of the Source Zips in that directory, not the EPL.</p>
-
-</body>
-</html>
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/about.ini b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/about.ini
deleted file mode 100644
index 2dee36a..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/about.ini
+++ /dev/null
@@ -1,31 +0,0 @@
-# about.ini
-# contains information about a feature
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# "%key" are externalized strings defined in about.properties
-# This file does not need to be translated.
-
-# Property "aboutText" contains blurb for "About" dialog (translated)
-aboutText=%blurb
-
-# Property "windowImage" contains path to window icon (16x16)
-# needed for primary features only
-
-# Property "featureImage" contains path to feature image (32x32)
-featureImage=eclipse32.gif
-
-# Property "aboutImage" contains path to product image (500x330 or 115x164)
-# needed for primary features only
-
-# Property "appName" contains name of the application (not translated)
-# needed for primary features only
-
-# Property "welcomePage" contains path to welcome page (special XML-based format)
-# optional
-
-# Property "welcomePerspective" contains the id of the perspective in which the
-# welcome page is to be opened.
-# optional
-
-
-
-
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/about.mappings b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/about.mappings
deleted file mode 100644
index a28390a..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/about.mappings
+++ /dev/null
@@ -1,6 +0,0 @@
-# about.mappings
-# contains fill-ins for about.properties
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file does not need to be translated.
-
-0=@build@
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/about.properties b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/about.properties
deleted file mode 100644
index c315cf8..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/about.properties
+++ /dev/null
@@ -1,27 +0,0 @@
-###############################################################################
-# Copyright (c) 2005, 2008 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-# Contributors:
-#    Oracle Corporation - initial API and implementation
-###############################################################################
-# This file should be translated.
-# about.properties
-# contains externalized strings for about.ini
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# fill-ins are supplied by about.mappings
-# This file should be translated.
-#
-# Do not translate any values surrounded by {}
-
-blurb=WTP Web Page Editor Apache MyFaces Trinidad Tag Support Source\n\
-\n\
-Version: {featureVersion}\n\
-Build id: {0}\n\
-\n\
-(c) Copyright Eclipse contributors and others 2007.  All rights reserved.\n\
-Visit http://www.eclipse.org/webtools
-
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/build.properties b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/build.properties
deleted file mode 100644
index 85ef5b7..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/build.properties
+++ /dev/null
@@ -1,13 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2008 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-
-bin.includes = about.html, about.ini, about.mappings, about.properties, eclipse32.gif, plugin.properties, plugin.xml, src/**, META-INF/
-sourcePlugin = true
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/eclipse32.gif b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/eclipse32.gif
deleted file mode 100644
index e6ad7cc..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/eclipse32.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/eclipse32.png b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/eclipse32.png
deleted file mode 100644
index 50ae49d..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/eclipse32.png
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/plugin.properties b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/plugin.properties
deleted file mode 100644
index 09fcddc..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateBundle/plugin.properties
+++ /dev/null
@@ -1,20 +0,0 @@
-###############################################################################
-# Copyright (c) 2005, 2008 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-# Contributors:
-#    Oracle Corporation - initial API and implementation
-###############################################################################
-# This file should be translated.
-# plugin.properties
-# contains externalized strings for manifest.mf
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# fill-ins are supplied by about.mappings
-# This file should be translated.
-#
-# Do not translate any values surrounded by {}
-pluginName=WTP Web Page Editor Apache MyFaces Trinidad Tag Support Source
-providerName=Eclipse.org
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateFeature/build.properties b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateFeature/build.properties
deleted file mode 100644
index 2395a38..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateFeature/build.properties
+++ /dev/null
@@ -1,17 +0,0 @@
-###############################################################################
-# Copyright (c) 2005, 2008 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-# Contributors:
-#    Oracle Corporation - initial API and implementation
-###############################################################################
-# This file should be NOT be translated.
-bin.includes =\
-eclipse_update_120.jpg,\
-feature.xml,\
-feature.properties,\
-
-
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateFeature/eclipse_update_120.jpg b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateFeature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateFeature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateFeature/feature.properties b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateFeature/feature.properties
deleted file mode 100644
index dab2333..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplateFeature/feature.properties
+++ /dev/null
@@ -1,50 +0,0 @@
-###############################################################################
-# Copyright (c) 2005, 2008 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-# Contributors:
-#    Oracle Corporation - initial API and implementation
-###############################################################################
-# This file should be translated.
-# feature.properties
-# contains externalized strings for feature.xml
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file should be translated.
-#
-# Do not translate any values surrounded by {}
-#
-# "featureName" property - name of the feature
-featureName=WTP Web Page Editor Apache MyFaces Trinidad Tag Support Source
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse.org
-
-
-# "description" property - description of the feature
-description=Source code zips for WTP Web Page Editor Apache MyFaces Trinidad Tag Support.
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2007 Oracle Corporation and others.\
-All rights reserved. This program and the accompanying materials\
-are made available under the terms of the Eclipse Public License v1.0\
-which accompanies this distribution, and is available at\
-http://www.eclipse.org/legal/epl-v10.html\
-\n\
-Contributors:\n\
-    Oracle Corporation - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism. 
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism. 
-########### end of license property ##########################################
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/about.html b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/about.html
deleted file mode 100644
index fe81d46..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/about.html
+++ /dev/null
@@ -1,27 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-<body lang="EN-US">
-<h2>About This Content</h2>
-
-<P>June, 2008</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 1.0 (&quot;EPL&quot;).  A copy of the EPL is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</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.</p>
-
-<h3>Source Code</h3>
-<p>This plug-in contains source code zip files (&quot;Source Zips&quot;) that correspond to binary content in other plug-ins. These Source Zips may be distributed under different license
-agreements and/or notices. Details about these license agreements and notices are contained in &quot;about.html&quot; files (&quot;Abouts&quot;) located in sub-directories in the
-src/ directory of this plug-in. Such Abouts govern your use of the Source Zips in that directory, not the EPL.</p>
-
-</body>
-</html>
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/about.ini b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/about.ini
deleted file mode 100644
index 2dee36a..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/about.ini
+++ /dev/null
@@ -1,31 +0,0 @@
-# about.ini
-# contains information about a feature
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# "%key" are externalized strings defined in about.properties
-# This file does not need to be translated.
-
-# Property "aboutText" contains blurb for "About" dialog (translated)
-aboutText=%blurb
-
-# Property "windowImage" contains path to window icon (16x16)
-# needed for primary features only
-
-# Property "featureImage" contains path to feature image (32x32)
-featureImage=eclipse32.gif
-
-# Property "aboutImage" contains path to product image (500x330 or 115x164)
-# needed for primary features only
-
-# Property "appName" contains name of the application (not translated)
-# needed for primary features only
-
-# Property "welcomePage" contains path to welcome page (special XML-based format)
-# optional
-
-# Property "welcomePerspective" contains the id of the perspective in which the
-# welcome page is to be opened.
-# optional
-
-
-
-
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/about.mappings b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/about.mappings
deleted file mode 100644
index a28390a..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/about.mappings
+++ /dev/null
@@ -1,6 +0,0 @@
-# about.mappings
-# contains fill-ins for about.properties
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file does not need to be translated.
-
-0=@build@
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/about.properties b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/about.properties
deleted file mode 100644
index c315cf8..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/about.properties
+++ /dev/null
@@ -1,27 +0,0 @@
-###############################################################################
-# Copyright (c) 2005, 2008 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-# Contributors:
-#    Oracle Corporation - initial API and implementation
-###############################################################################
-# This file should be translated.
-# about.properties
-# contains externalized strings for about.ini
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# fill-ins are supplied by about.mappings
-# This file should be translated.
-#
-# Do not translate any values surrounded by {}
-
-blurb=WTP Web Page Editor Apache MyFaces Trinidad Tag Support Source\n\
-\n\
-Version: {featureVersion}\n\
-Build id: {0}\n\
-\n\
-(c) Copyright Eclipse contributors and others 2007.  All rights reserved.\n\
-Visit http://www.eclipse.org/webtools
-
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/build.properties b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/build.properties
deleted file mode 100644
index 85ef5b7..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/build.properties
+++ /dev/null
@@ -1,13 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2008 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-
-bin.includes = about.html, about.ini, about.mappings, about.properties, eclipse32.gif, plugin.properties, plugin.xml, src/**, META-INF/
-sourcePlugin = true
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/eclipse32.gif b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/eclipse32.gif
deleted file mode 100644
index e6ad7cc..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/eclipse32.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/eclipse32.png b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/eclipse32.png
deleted file mode 100644
index 50ae49d..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/eclipse32.png
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/plugin.properties b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/plugin.properties
deleted file mode 100644
index 09fcddc..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature/sourceTemplatePlugin/plugin.properties
+++ /dev/null
@@ -1,20 +0,0 @@
-###############################################################################
-# Copyright (c) 2005, 2008 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-# Contributors:
-#    Oracle Corporation - initial API and implementation
-###############################################################################
-# This file should be translated.
-# plugin.properties
-# contains externalized strings for manifest.mf
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# fill-ins are supplied by about.mappings
-# This file should be translated.
-#
-# Do not translate any values surrounded by {}
-pluginName=WTP Web Page Editor Apache MyFaces Trinidad Tag Support Source
-providerName=Eclipse.org
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport_sdk.feature/.project b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport_sdk.feature/.project
deleted file mode 100644
index 8ff0421..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport_sdk.feature/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jst.jsf.apache.trinidad.tagsupport_sdk.feature</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.FeatureBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.FeatureNature</nature>
-	</natures>
-</projectDescription>
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport_sdk.feature/build.properties b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport_sdk.feature/build.properties
deleted file mode 100644
index 378cdaf..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport_sdk.feature/build.properties
+++ /dev/null
@@ -1,15 +0,0 @@
-###############################################################################
-# Copyright (c)  2008 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-bin.includes = feature.xml,\
-               eclipse_update_120.jpg,\
-               feature.properties,\
-
-generate.feature@org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature.source = org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport_sdk.feature/eclipse_update_120.jpg b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport_sdk.feature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport_sdk.feature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport_sdk.feature/feature.properties b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport_sdk.feature/feature.properties
deleted file mode 100644
index 522ca43..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport_sdk.feature/feature.properties
+++ /dev/null
@@ -1,48 +0,0 @@
-###############################################################################
-# Copyright (c) 2008 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-# Contributors:
-#    Oracle Corporation - initial API and implementation
-###############################################################################
-# feature.properties
-# contains externalized strings for feature.xml
-# "%foo" in feature.xml corresponds to the key "foo" in this file
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file should be translated.
-
-# "featureName" property - name of the feature
-featureName=Apache MyFaces Trinidad Tag Support (Optional) SDK
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse.org
-
-
-# "description" property - description of the feature
-description=Apache MyFaces Trinidad Tag Support (Optional) SDK
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2008 Oracle Corporation.\n\
-All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
-which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
-\n\
-Contributors:\n\
-    Oracle Corporation - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism. 
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism. 
-########### end of license property ##########################################
diff --git a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport_sdk.feature/feature.xml b/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport_sdk.feature/feature.xml
deleted file mode 100644
index 1b3b738..0000000
--- a/jsf/features/org.eclipse.jst.jsf.apache.trinidad.tagsupport_sdk.feature/feature.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jst.jsf.apache.trinidad.tagsupport_sdk.feature"
-      label="%featureName"
-      version="2.2.200.qualifier"
-      provider-name="%providerName"
-      license-feature="org.eclipse.license"
-      license-feature-version="1.0.0.qualifier">
-
-   <description>
-      %description
-   </description>
-
-   <copyright>
-      %copyright
-   </copyright>
-
-   <license url="license.html">
-      %license
-   </license>
-
-   <includes
-         id="org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature"
-         version="0.0.0"/>
-
-   <includes
-         id="org.eclipse.jst.jsf.apache.trinidad.tagsupport.feature.source"
-         version="0.0.0"/>
-
-</feature>
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/.cvsignore b/jsf/features/org.eclipse.jst.webpageeditor.feature/.cvsignore
deleted file mode 100644
index c14487c..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/.cvsignore
+++ /dev/null
@@ -1 +0,0 @@
-build.xml
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/.project b/jsf/features/org.eclipse.jst.webpageeditor.feature/.project
deleted file mode 100644
index e089155..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jst.webpageeditor.feature</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.FeatureBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.FeatureNature</nature>
-	</natures>
-</projectDescription>
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/build.properties b/jsf/features/org.eclipse.jst.webpageeditor.feature/build.properties
deleted file mode 100644
index 6b1e9bf..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/build.properties
+++ /dev/null
@@ -1,13 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-bin.includes = feature.xml,\
-               feature.properties,\
-               eclipse_update_120.jpg
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/eclipse_update_120.jpg b/jsf/features/org.eclipse.jst.webpageeditor.feature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/feature.properties b/jsf/features/org.eclipse.jst.webpageeditor.feature/feature.properties
deleted file mode 100644
index ef497e3..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/feature.properties
+++ /dev/null
@@ -1,51 +0,0 @@
-###############################################################################
-# Copyright (c) 2005, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-# feature.properties
-# contains externalized strings for feature.xml
-# "%foo" in feature.xml corresponds to the key "foo" in this file
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file should be translated.
-
-# "featureName" property - name of the feature
-featureName=Web Page Editor (Optional)
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse.org
-
-
-# "description" property - description of the feature
-description=Web Page Editor (Optional)
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism.
-
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2007 Oracle Corporation.\
-All rights reserved. This program and the accompanying materials\
-are made available under the terms of the Eclipse Public License v1.0\
-which accompanies this distribution, and is available at\
-http://www.eclipse.org/legal/epl-v10.html\
-\n\
-Contributors:\n\
-    Oracle Corporation - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism. 
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism. 
-########### end of license property ##########################################
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/feature.xml b/jsf/features/org.eclipse.jst.webpageeditor.feature/feature.xml
deleted file mode 100644
index 4966275..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/feature.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jst.webpageeditor.feature"
-      label="%featureName"
-      version="2.3.3.qualifier"
-      provider-name="%providerName"
-      image="eclipse_update_120.jpg"
-      license-feature="org.eclipse.license"
-      license-feature-version="1.0.0.qualifier">
-
-   <description>
-      %description
-   </description>
-
-   <copyright>
-      %copyright
-   </copyright>
-
-   <license url="license.html">
-      %license
-   </license>
-
-   <plugin
-         id="org.eclipse.jst.pagedesigner"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jst.pagedesigner.jsf.ui"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-   <plugin
-         id="org.eclipse.jst.pagedesigner.jsp.core"
-         download-size="0"
-         install-size="0"
-         version="0.0.0"
-         unpack="false"/>
-
-</feature>
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/about.html b/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/about.html
deleted file mode 100644
index fe81d46..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/about.html
+++ /dev/null
@@ -1,27 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-<body lang="EN-US">
-<h2>About This Content</h2>
-
-<P>June, 2008</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 1.0 (&quot;EPL&quot;).  A copy of the EPL is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</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.</p>
-
-<h3>Source Code</h3>
-<p>This plug-in contains source code zip files (&quot;Source Zips&quot;) that correspond to binary content in other plug-ins. These Source Zips may be distributed under different license
-agreements and/or notices. Details about these license agreements and notices are contained in &quot;about.html&quot; files (&quot;Abouts&quot;) located in sub-directories in the
-src/ directory of this plug-in. Such Abouts govern your use of the Source Zips in that directory, not the EPL.</p>
-
-</body>
-</html>
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/about.ini b/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/about.ini
deleted file mode 100644
index 2dee36a..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/about.ini
+++ /dev/null
@@ -1,31 +0,0 @@
-# about.ini
-# contains information about a feature
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# "%key" are externalized strings defined in about.properties
-# This file does not need to be translated.
-
-# Property "aboutText" contains blurb for "About" dialog (translated)
-aboutText=%blurb
-
-# Property "windowImage" contains path to window icon (16x16)
-# needed for primary features only
-
-# Property "featureImage" contains path to feature image (32x32)
-featureImage=eclipse32.gif
-
-# Property "aboutImage" contains path to product image (500x330 or 115x164)
-# needed for primary features only
-
-# Property "appName" contains name of the application (not translated)
-# needed for primary features only
-
-# Property "welcomePage" contains path to welcome page (special XML-based format)
-# optional
-
-# Property "welcomePerspective" contains the id of the perspective in which the
-# welcome page is to be opened.
-# optional
-
-
-
-
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/about.mappings b/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/about.mappings
deleted file mode 100644
index a28390a..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/about.mappings
+++ /dev/null
@@ -1,6 +0,0 @@
-# about.mappings
-# contains fill-ins for about.properties
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file does not need to be translated.
-
-0=@build@
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/about.properties b/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/about.properties
deleted file mode 100644
index e3cbbc3..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/about.properties
+++ /dev/null
@@ -1,27 +0,0 @@
-###############################################################################
-# Copyright (c) 2005, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-# Contributors:
-#    Gerry Kessler - initial API and implementation
-###############################################################################
-# This file should be translated.
-# about.properties
-# contains externalized strings for about.ini
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# fill-ins are supplied by about.mappings
-# This file should be translated.
-#
-# Do not translate any values surrounded by {}
-
-blurb=Web Page Editor Source\n\
-\n\
-Version: {featureVersion}\n\
-Build id: {0}\n\
-\n\
-(c) Copyright Eclipse contributors and others 2007.  All rights reserved.\n\
-Visit http://www.eclipse.org/webtools
-
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/build.properties b/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/build.properties
deleted file mode 100644
index 43309f0..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/build.properties
+++ /dev/null
@@ -1,13 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-
-bin.includes = about.html, about.ini, about.mappings, about.properties, eclipse32.gif, plugin.properties, plugin.xml, src/**, META-INF/
-sourcePlugin = true
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/eclipse32.gif b/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/eclipse32.gif
deleted file mode 100644
index e6ad7cc..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/eclipse32.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/eclipse32.png b/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/eclipse32.png
deleted file mode 100644
index 50ae49d..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/eclipse32.png
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/plugin.properties b/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/plugin.properties
deleted file mode 100644
index 46b3449..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateBundle/plugin.properties
+++ /dev/null
@@ -1,20 +0,0 @@
-###############################################################################
-# Copyright (c) 2005, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-# Contributors:
-#    Gerry Kessler - initial API and implementation
-###############################################################################
-# This file should be translated.
-# plugin.properties
-# contains externalized strings for manifest.mf
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# fill-ins are supplied by about.mappings
-# This file should be translated.
-#
-# Do not translate any values surrounded by {}
-pluginName=Web Page Editor Source
-providerName=Eclipse.org
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateFeature/build.properties b/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateFeature/build.properties
deleted file mode 100644
index e83a716..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateFeature/build.properties
+++ /dev/null
@@ -1,17 +0,0 @@
-###############################################################################
-# Copyright (c) 2005, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-# Contributors:
-#    Gerry Kessler - initial API and implementation
-###############################################################################
-# This file should be NOT be translated.
-bin.includes =\
-eclipse_update_120.jpg,\
-feature.xml,\
-feature.properties,\
-
-
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateFeature/eclipse_update_120.jpg b/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateFeature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateFeature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateFeature/feature.properties b/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateFeature/feature.properties
deleted file mode 100644
index d0de64b..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplateFeature/feature.properties
+++ /dev/null
@@ -1,50 +0,0 @@
-###############################################################################
-# Copyright (c) 2005, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-# Contributors:
-#    Gerry Kessler - initial API and implementation
-###############################################################################
-# This file should be translated.
-# feature.properties
-# contains externalized strings for feature.xml
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file should be translated.
-#
-# Do not translate any values surrounded by {}
-#
-# "featureName" property - name of the feature
-featureName=Web Page Editor Source
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse Web Tools Platform
-
-
-# "description" property - description of the feature
-description=Source code zips for Web Page Editor.
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2007 Oracle Corporation and others.\
-All rights reserved. This program and the accompanying materials\
-are made available under the terms of the Eclipse Public License v1.0\
-which accompanies this distribution, and is available at\
-http://www.eclipse.org/legal/epl-v10.html\
-\n\
-Contributors:\n\
-    Oracle Corporation - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism. 
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism. 
-########### end of license property ##########################################
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/about.html b/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/about.html
deleted file mode 100644
index fe81d46..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/about.html
+++ /dev/null
@@ -1,27 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-<body lang="EN-US">
-<h2>About This Content</h2>
-
-<P>June, 2008</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 1.0 (&quot;EPL&quot;).  A copy of the EPL is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</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.</p>
-
-<h3>Source Code</h3>
-<p>This plug-in contains source code zip files (&quot;Source Zips&quot;) that correspond to binary content in other plug-ins. These Source Zips may be distributed under different license
-agreements and/or notices. Details about these license agreements and notices are contained in &quot;about.html&quot; files (&quot;Abouts&quot;) located in sub-directories in the
-src/ directory of this plug-in. Such Abouts govern your use of the Source Zips in that directory, not the EPL.</p>
-
-</body>
-</html>
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/about.ini b/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/about.ini
deleted file mode 100644
index 2dee36a..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/about.ini
+++ /dev/null
@@ -1,31 +0,0 @@
-# about.ini
-# contains information about a feature
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# "%key" are externalized strings defined in about.properties
-# This file does not need to be translated.
-
-# Property "aboutText" contains blurb for "About" dialog (translated)
-aboutText=%blurb
-
-# Property "windowImage" contains path to window icon (16x16)
-# needed for primary features only
-
-# Property "featureImage" contains path to feature image (32x32)
-featureImage=eclipse32.gif
-
-# Property "aboutImage" contains path to product image (500x330 or 115x164)
-# needed for primary features only
-
-# Property "appName" contains name of the application (not translated)
-# needed for primary features only
-
-# Property "welcomePage" contains path to welcome page (special XML-based format)
-# optional
-
-# Property "welcomePerspective" contains the id of the perspective in which the
-# welcome page is to be opened.
-# optional
-
-
-
-
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/about.mappings b/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/about.mappings
deleted file mode 100644
index a28390a..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/about.mappings
+++ /dev/null
@@ -1,6 +0,0 @@
-# about.mappings
-# contains fill-ins for about.properties
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file does not need to be translated.
-
-0=@build@
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/about.properties b/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/about.properties
deleted file mode 100644
index e3cbbc3..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/about.properties
+++ /dev/null
@@ -1,27 +0,0 @@
-###############################################################################
-# Copyright (c) 2005, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-# Contributors:
-#    Gerry Kessler - initial API and implementation
-###############################################################################
-# This file should be translated.
-# about.properties
-# contains externalized strings for about.ini
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# fill-ins are supplied by about.mappings
-# This file should be translated.
-#
-# Do not translate any values surrounded by {}
-
-blurb=Web Page Editor Source\n\
-\n\
-Version: {featureVersion}\n\
-Build id: {0}\n\
-\n\
-(c) Copyright Eclipse contributors and others 2007.  All rights reserved.\n\
-Visit http://www.eclipse.org/webtools
-
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/build.properties b/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/build.properties
deleted file mode 100644
index 43309f0..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/build.properties
+++ /dev/null
@@ -1,13 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-
-bin.includes = about.html, about.ini, about.mappings, about.properties, eclipse32.gif, plugin.properties, plugin.xml, src/**, META-INF/
-sourcePlugin = true
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/eclipse32.gif b/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/eclipse32.gif
deleted file mode 100644
index e6ad7cc..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/eclipse32.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/eclipse32.png b/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/eclipse32.png
deleted file mode 100644
index 50ae49d..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/eclipse32.png
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/plugin.properties b/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/plugin.properties
deleted file mode 100644
index 46b3449..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor.feature/sourceTemplatePlugin/plugin.properties
+++ /dev/null
@@ -1,20 +0,0 @@
-###############################################################################
-# Copyright (c) 2005, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-# Contributors:
-#    Gerry Kessler - initial API and implementation
-###############################################################################
-# This file should be translated.
-# plugin.properties
-# contains externalized strings for manifest.mf
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# fill-ins are supplied by about.mappings
-# This file should be translated.
-#
-# Do not translate any values surrounded by {}
-pluginName=Web Page Editor Source
-providerName=Eclipse.org
diff --git a/jsf/features/org.eclipse.jst.webpageeditor_sdk.feature/.cvsignore b/jsf/features/org.eclipse.jst.webpageeditor_sdk.feature/.cvsignore
deleted file mode 100644
index c14487c..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor_sdk.feature/.cvsignore
+++ /dev/null
@@ -1 +0,0 @@
-build.xml
diff --git a/jsf/features/org.eclipse.jst.webpageeditor_sdk.feature/.project b/jsf/features/org.eclipse.jst.webpageeditor_sdk.feature/.project
deleted file mode 100644
index 1e4ee00..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor_sdk.feature/.project
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jst.webpageeditor_sdk.feature</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.pde.FeatureBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.pde.FeatureNature</nature>
-	</natures>
-</projectDescription>
diff --git a/jsf/features/org.eclipse.jst.webpageeditor_sdk.feature/build.properties b/jsf/features/org.eclipse.jst.webpageeditor_sdk.feature/build.properties
deleted file mode 100644
index d4a63ac..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor_sdk.feature/build.properties
+++ /dev/null
@@ -1,16 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-bin.includes = feature.xml,\
-               feature.properties,\
-               eclipse_update_120.jpg
-
-generate.feature@org.eclipse.jst.webpageeditor.feature.source = org.eclipse.jst.webpageeditor.feature
-               
diff --git a/jsf/features/org.eclipse.jst.webpageeditor_sdk.feature/eclipse_update_120.jpg b/jsf/features/org.eclipse.jst.webpageeditor_sdk.feature/eclipse_update_120.jpg
deleted file mode 100644
index bfdf708..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor_sdk.feature/eclipse_update_120.jpg
+++ /dev/null
Binary files differ
diff --git a/jsf/features/org.eclipse.jst.webpageeditor_sdk.feature/feature.properties b/jsf/features/org.eclipse.jst.webpageeditor_sdk.feature/feature.properties
deleted file mode 100644
index 5490cac..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor_sdk.feature/feature.properties
+++ /dev/null
@@ -1,51 +0,0 @@
-###############################################################################
-# Copyright (c) 2005, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-# feature.properties
-# contains externalized strings for feature.xml
-# "%foo" in feature.xml corresponds to the key "foo" in this file
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file should be translated.
-
-# "featureName" property - name of the feature
-featureName=Web Page Editor (Optional) SDK
-
-# "providerName" property - name of the company that provides the feature
-providerName=Eclipse.org
-
-
-# "description" property - description of the feature
-description=Web Page Editor (Optional) SDK
-
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism.
-
-# "copyright" property - text of the "Feature Update Copyright"
-copyright=\
-Copyright (c) 2007 Oracle Corporation.\
-All rights reserved. This program and the accompanying materials\
-are made available under the terms of the Eclipse Public License v1.0\
-which accompanies this distribution, and is available at\
-http://www.eclipse.org/legal/epl-v10.html\
-\n\
-Contributors:\n\
-    Oracle Corporation - initial API and implementation\n
-################ end of copyright property ####################################
-
-# "licenseURL" property - URL of the "Feature License"
-# do not translate value - just change to point to a locale-specific HTML page
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism. 
-
-# "license" property - text of the "Feature Update License"
-# should be plain text version of license agreement pointed to be "licenseURL"
-# license and licenseURL properties were removed as a result to migrating to new PDE license support. 
-#    Those properties are now added at build time. See http://wiki.eclipse.org/Equinox/p2/License_Mechanism. 
-########### end of license property ##########################################
diff --git a/jsf/features/org.eclipse.jst.webpageeditor_sdk.feature/feature.xml b/jsf/features/org.eclipse.jst.webpageeditor_sdk.feature/feature.xml
deleted file mode 100644
index 16e24d0..0000000
--- a/jsf/features/org.eclipse.jst.webpageeditor_sdk.feature/feature.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<feature
-      id="org.eclipse.jst.webpageeditor_sdk.feature"
-      label="%featureName"
-      version="2.3.3.qualifier"
-      provider-name="%providerName"
-      license-feature="org.eclipse.license"
-      license-feature-version="1.0.0.qualifier">
-
-   <description>
-      %description
-   </description>
-
-   <copyright>
-      %copyright
-   </copyright>
-
-   <license url="license.html">
-      %license
-   </license>
-
-   <includes
-         id="org.eclipse.jst.webpageeditor.feature"
-         version="0.0.0"/>
-
-   <includes
-         id="org.eclipse.jst.webpageeditor.feature.source"
-         version="0.0.0"/>
-
-</feature>
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/.classpath b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/.classpath
deleted file mode 100644
index 64c5e31..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/.classpath
+++ /dev/null
@@ -1,7 +0,0 @@
-<?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/J2SE-1.5"/>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="output" path="bin"/>
-</classpath>
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/.cvsignore b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/.cvsignore
deleted file mode 100644
index a179f16..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/.cvsignore
+++ /dev/null
@@ -1,3 +0,0 @@
-@dot
-build.xml
-javaCompiler...args
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/.project b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/.project
deleted file mode 100644
index 4fe172b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/.project
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jst.jsf.common.runtime</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/jsf/plugins/org.eclipse.jst.jsf.common.runtime/.settings/org.eclipse.jdt.core.prefs b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/.settings/org.eclipse.jdt.core.prefs
deleted file mode 100644
index 0df408f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/.settings/org.eclipse.jdt.core.prefs
+++ /dev/null
@@ -1,82 +0,0 @@
-#Tue Mar 02 08:23:18 PST 2010
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
-org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.5
-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.doc.comment.support=enabled
-org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.autoboxing=warning
-org.eclipse.jdt.core.compiler.problem.deprecation=error
-org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
-org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
-org.eclipse.jdt.core.compiler.problem.discouragedReference=ignore
-org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore
-org.eclipse.jdt.core.compiler.problem.fatalOptionalError=enabled
-org.eclipse.jdt.core.compiler.problem.fieldHiding=warning
-org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
-org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
-org.eclipse.jdt.core.compiler.problem.forbiddenReference=error
-org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
-org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
-org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=warning
-org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
-org.eclipse.jdt.core.compiler.problem.invalidJavadoc=error
-org.eclipse.jdt.core.compiler.problem.invalidJavadocTags=enabled
-org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef=disabled
-org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef=disabled
-org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=protected
-org.eclipse.jdt.core.compiler.problem.localVariableHiding=warning
-org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
-org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingJavadocComments=warning
-org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=protected
-org.eclipse.jdt.core.compiler.problem.missingJavadocTags=warning
-org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=protected
-org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning
-org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
-org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
-org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=error
-org.eclipse.jdt.core.compiler.problem.nullReference=ignore
-org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
-org.eclipse.jdt.core.compiler.problem.parameterAssignment=ignore
-org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=warning
-org.eclipse.jdt.core.compiler.problem.potentialNullReference=ignore
-org.eclipse.jdt.core.compiler.problem.rawTypeReference=ignore
-org.eclipse.jdt.core.compiler.problem.redundantNullCheck=ignore
-org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=ignore
-org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
-org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
-org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled
-org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
-org.eclipse.jdt.core.compiler.problem.typeParameterHiding=ignore
-org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=ignore
-org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=error
-org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning
-org.eclipse.jdt.core.compiler.problem.unnecessaryElse=warning
-org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=warning
-org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=warning
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable=enabled
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference=enabled
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.unusedImport=error
-org.eclipse.jdt.core.compiler.problem.unusedLabel=warning
-org.eclipse.jdt.core.compiler.problem.unusedLocal=error
-org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
-org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference=enabled
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
-org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=error
-org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
-org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.compiler.source=1.5
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/.settings/org.eclipse.pde.prefs b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/.settings/org.eclipse.pde.prefs
deleted file mode 100644
index 997a930..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/.settings/org.eclipse.pde.prefs
+++ /dev/null
@@ -1,22 +0,0 @@
-#Fri May 30 11:44:25 PDT 2008
-compilers.f.unresolved-features=1
-compilers.f.unresolved-plugins=1
-compilers.incompatible-environment=1
-compilers.p.build=1
-compilers.p.deprecated=1
-compilers.p.discouraged-class=1
-compilers.p.internal=1
-compilers.p.missing-packages=0
-compilers.p.no-required-att=0
-compilers.p.not-externalized-att=0
-compilers.p.unknown-attribute=1
-compilers.p.unknown-class=1
-compilers.p.unknown-element=1
-compilers.p.unknown-identifier=1
-compilers.p.unknown-resource=1
-compilers.p.unresolved-ex-points=0
-compilers.p.unresolved-import=0
-compilers.s.create-docs=false
-compilers.s.doc-folder=doc
-compilers.s.open-tags=1
-eclipse.preferences.version=1
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/META-INF/MANIFEST.MF b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/META-INF/MANIFEST.MF
deleted file mode 100644
index e04c87f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,22 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: %Bundle-Name.0
-Bundle-SymbolicName: org.eclipse.jst.jsf.common.runtime
-Bundle-Version: 1.1.0.qualifier
-Bundle-Activator: org.eclipse.jst.jsf.common.runtime.internal.JSFCommonRuntimePlugin
-Require-Bundle: org.eclipse.core.runtime
-Bundle-ActivationPolicy: lazy
-Bundle-RequiredExecutionEnvironment: J2SE-1.5
-Export-Package: org.eclipse.jst.jsf.common.runtime.internal;x-internal:=true,
- org.eclipse.jst.jsf.common.runtime.internal.debug;x-friends:="org.eclipse.jst.jsf.common.runtime.tests",
- org.eclipse.jst.jsf.common.runtime.internal.model;x-friends:="org.eclipse.jst.jsf.common.runtime.tests",
- org.eclipse.jst.jsf.common.runtime.internal.model.bean;x-friends:="org.eclipse.jst.jsf.common.runtime.tests",
- org.eclipse.jst.jsf.common.runtime.internal.model.behavioural;x-friends:="org.eclipse.jst.jsf.common.runtime.tests",
- org.eclipse.jst.jsf.common.runtime.internal.model.component;x-friends:="org.eclipse.jst.jsf.common.runtime.tests",
- org.eclipse.jst.jsf.common.runtime.internal.model.datatypes;x-friends:="org.eclipse.jst.jsf.common.runtime.tests",
- org.eclipse.jst.jsf.common.runtime.internal.model.decorator;x-friends:="org.eclipse.jst.jsf.common.runtime.tests",
- org.eclipse.jst.jsf.common.runtime.internal.model.event;x-friends:="org.eclipse.jst.jsf.common.runtime.tests",
- org.eclipse.jst.jsf.common.runtime.internal.model.types;x-friends:="org.eclipse.jst.jsf.common.runtime.tests",
- org.eclipse.jst.jsf.common.runtime.internal.view.model.common;x-friends:="org.eclipse.jst.jsf.common.runtime.tests"
-Bundle-Vendor: %Bundle-Vendor.0
-Bundle-Localization: plugin
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/about.html b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/about.html
deleted file mode 100644
index 8e56059..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/about.html
+++ /dev/null
@@ -1,22 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-<body lang="EN-US">
-<h2>About This Content</h2>
- 
-<p>June, 2008</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 1.0 (&quot;EPL&quot;).  A copy of the EPL is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</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.</p>
-
-</body>
-</html>
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/build.properties b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/build.properties
deleted file mode 100644
index ce7a0fa..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/build.properties
+++ /dev/null
@@ -1,16 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2008 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-source.. = src/
-output.. = bin/
-bin.includes = META-INF/,\
-               .,\
-               plugin.properties,\
-               about.html
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/instrumentation/WebContent/WEB-INF/faces-config.xml b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/instrumentation/WebContent/WEB-INF/faces-config.xml
deleted file mode 100644
index 15eef3b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/instrumentation/WebContent/WEB-INF/faces-config.xml
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<!DOCTYPE faces-config PUBLIC
-    "-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.1//EN"
-    "http://java.sun.com/dtd/web-facesconfig_1_1.dtd">
-
-<faces-config>
-	<lifecycle>
-		<phase-listener>
-		instrument.PhaseListener1</phase-listener>
-	</lifecycle>
-</faces-config>
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/instrumentation/jar/jsfrt.jar b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/instrumentation/jar/jsfrt.jar
deleted file mode 100644
index 5093673..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/instrumentation/jar/jsfrt.jar
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/instrumentation/src/instrument/MyMonitorMessageFactory.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/instrumentation/src/instrument/MyMonitorMessageFactory.java
deleted file mode 100644
index 3f06d6d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/instrumentation/src/instrument/MyMonitorMessageFactory.java
+++ /dev/null
@@ -1,132 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package instrument;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.ObjectInputStream;
-import java.util.Iterator;
-
-import javax.faces.component.UIComponent;
-import javax.faces.component.UIInput;
-import javax.faces.component.UIOutput;
-
-import org.eclipse.jst.jsf.common.runtime.internal.debug.JSFMonitorMessage;
-import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentFactory;
-import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentInfo;
-import org.eclipse.jst.jsf.common.runtime.internal.model.component.FacetInfo;
-import org.eclipse.jst.jsf.common.runtime.internal.model.component.UIInputInfo;
-import org.eclipse.jst.jsf.common.runtime.internal.model.component.UIOutputInfo;
-
-public class MyMonitorMessageFactory 
-{
-    public static JSFMonitorMessage  createJSFMonitorMessage(InputStream inStream) throws IOException, ClassCastException, ClassNotFoundException
-    {
-        ObjectInputStream objectStream = new ObjectInputStream(inStream);
-        Object nextObject = objectStream.readObject();
-        return (JSFMonitorMessage) nextObject;
-    }
-   
-    static ComponentInfo buildComponentTree(UIComponent component, boolean isFacet)
-    {
-        final ComponentInfo componentInfo = getComponentData(component, isFacet);
-        
-        for (Iterator it = component.getChildren().iterator(); it.hasNext();)
-        {
-            UIComponent child = (UIComponent) it.next();
-            componentInfo.getChildren().add(buildComponentTree(child, false));
-        }
-
-        for (Iterator it = component.getFacets().values().iterator(); it.hasNext();)
-        {
-            UIComponent facet = (UIComponent) it.next();
-            componentInfo.getChildren().add(buildComponentTree(facet, true));
-        }
-        
-        return componentInfo;
-    }
-    
-    private static ComponentInfo getComponentData(final UIComponent component, boolean isFacet)
-    {
-        if (isFacet)
-        {
-            return calculateFacetInfo(component);
-        }
-        else if (component instanceof UIInput)
-        {
-            return calculateUIInput((UIInput)component);
-        }
-        else if (component instanceof UIOutput)
-        {
-            return calculateUIOutput((UIOutput)component);
-        }
-        
-        // default; just make a component
-        return calculateComponentInfo(component);
-    }
-
-    private static ComponentInfo calculateComponentInfo(UIComponent component)
-    {
-        final String id = component.getId();
-        final String parentId = component.getParent() == null ? null : component.getParent().getId();
-        final String componentFamily = component.getFamily();
-        final String renderFamily = component.getRendererType();
-        final String componentType = null;
-        final String componentClass = component.getClass().getCanonicalName();
-        
-        return ComponentFactory.createComponentInfo
-            (id, parentId, componentFamily, renderFamily, componentType, componentClass);
-    }
-    
-    private static FacetInfo calculateFacetInfo(UIComponent component)
-    {
-        final String id = component.getId();
-        final String parentId = component.getParent() == null ? null : component.getParent().getId();
-        final String componentFamily = component.getFamily();
-        final String renderFamily = component.getRendererType();
-        final String componentType = null;
-        final String componentClass = component.getClass().getCanonicalName();
-
-        return ComponentFactory.createFacetInfo
-            (id, parentId, componentFamily, renderFamily, componentType, componentClass);
-    }
-    
-    private static UIInputInfo calculateUIInput(UIInput  uiInput)
-    {
-        final String id = uiInput.getId();
-        final String parentId = uiInput.getParent() == null ? null : uiInput.getParent().getId();
-        final String componentFamily = uiInput.getFamily();
-        final String renderFamily = uiInput.getRendererType();
-        final String componentType = null;
-        final String componentClass = uiInput.getClass().getCanonicalName();
-        final String isValid = Boolean.toString(uiInput.isValid());
-        final String isImmediate = Boolean.toString(uiInput.isImmediate());
-        final String isRequired = Boolean.toString(uiInput.isRequired());
-        final String isRendered = Boolean.toString(uiInput.isRendered());
-
-        return ComponentFactory.createUIInputInfo
-            (id, parentId, componentFamily, renderFamily, isValid, isImmediate, isRequired, isRendered, componentType, componentClass);
-    }
-
-    private static UIOutputInfo calculateUIOutput(UIOutput uiOutput)
-    {
-        final String id = uiOutput.getId();
-        final String parentId = uiOutput.getParent() == null ? null : uiOutput.getParent().getId();
-        final String componentFamily = uiOutput.getFamily();
-        final String renderFamily = uiOutput.getRendererType();
-        final String componentType = null;
-        final String componentClass = uiOutput.getClass().getCanonicalName();
-        final String isRendered = Boolean.toString(uiOutput.isRendered());
-
-        return ComponentFactory.createUIOutputInfo
-            (id, parentId, componentFamily, renderFamily, isRendered, componentType, componentClass);
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/instrumentation/src/instrument/PhaseListener1.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/instrumentation/src/instrument/PhaseListener1.java
deleted file mode 100644
index e93e028..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/instrumentation/src/instrument/PhaseListener1.java
+++ /dev/null
@@ -1,342 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package instrument;
-
-import java.io.IOException;
-import java.io.ObjectOutputStream;
-import java.io.Writer;
-import java.net.Socket;
-import java.net.UnknownHostException;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Stack;
-import java.util.concurrent.LinkedBlockingQueue;
-
-import javax.faces.FactoryFinder;
-import javax.faces.component.UIComponent;
-import javax.faces.component.UIViewRoot;
-import javax.faces.context.FacesContext;
-import javax.faces.context.ResponseWriter;
-import javax.faces.event.PhaseEvent;
-import javax.faces.event.PhaseId;
-import javax.faces.event.PhaseListener;
-import javax.faces.render.RenderKit;
-import javax.faces.render.RenderKitFactory;
-import javax.servlet.ServletRequest;
-import javax.servlet.ServletResponse;
-
-import org.eclipse.jst.jsf.common.runtime.internal.debug.ComponentTreeMessage;
-import org.eclipse.jst.jsf.common.runtime.internal.debug.JSFMonitorMessage;
-import org.eclipse.jst.jsf.common.runtime.internal.debug.MonitorMessageFactory;
-import org.eclipse.jst.jsf.common.runtime.internal.debug.RenderAttribute;
-import org.eclipse.jst.jsf.common.runtime.internal.debug.RenderNode;
-import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentInfo;
-
-/**
- * @author cbateman
- *
- */
-public class PhaseListener1 implements PhaseListener 
-{
-	SocketClient		_socketClient;
-	ResponseWriter		_savedRW;
-	LoggingResponseWriter  _injectRW;
-	
-	/**
-	 * 
-	 */
-	private static final long serialVersionUID = 6564874625827591775L;
-
-	public PhaseListener1()
-	{
-		System.out.println("Initialized PhaseListener: "+this);
-		_socketClient = new SocketClient(3702);
-		Thread thread = new Thread(_socketClient);
-		thread.start();
-		
-	}
-	
-	public void afterPhase(PhaseEvent event) {
-		if(PhaseId.RENDER_RESPONSE.equals(event.getPhaseId()))
-		{
-			System.out.printf("afterPhase: %s, for view id: %s\n",event.getPhaseId(),event.getFacesContext().getViewRoot().getViewId());
-			dumpComponentTree(event.getFacesContext());
-			
-			if (_savedRW != null)
-			{
-				event.getFacesContext().setResponseWriter(_savedRW);
-			}
-			
-			if (_injectRW != null)
-			{
-				dumpNode(_injectRW._rootComponentNode, "");
-			}
-		}
-	}
-
-	private void dumpNode(RenderNode node, String prefix)
-	{
-		System.out.printf("%s%s for component %s\n", prefix, node.getRenderedNodeName(), node.getComponentId());
-
-		for (final Iterator it = node.getChildren().iterator();it.hasNext();)
-		{
-			RenderNode child = (RenderNode) it.next();
-			dumpNode(child, prefix+"\t");
-		}
-	}
-
-	public void beforePhase(PhaseEvent event) {
-		if (PhaseId.RENDER_RESPONSE.equals(event.getPhaseId()))
-		{
-			FacesContext facesContext = event.getFacesContext();
-            RenderKitFactory renderFactory = 
-            	(RenderKitFactory)FactoryFinder.getFactory(FactoryFinder.RENDER_KIT_FACTORY);
-            RenderKit renderKit = renderFactory.getRenderKit(facesContext,
-                                                             facesContext.getViewRoot().getRenderKitId());
-
-            _savedRW = facesContext.getResponseWriter();
-
-            try
-            {
-	            Writer writer = ((ServletResponse) facesContext.getExternalContext().getResponse()).getWriter();
-	            String charEncoding = ((ServletRequest)facesContext.getExternalContext().getRequest()).getCharacterEncoding();
-	            ResponseWriter responseWriter = renderKit.createResponseWriter
-	            	(writer,
-	                                           null /*Default: get the allowed content-types from the accept-header*/,
-	                                           charEncoding);
-	            _injectRW = new LoggingResponseWriter(responseWriter);
-	            facesContext.setResponseWriter(_injectRW);
-            }
-            catch (IOException ioe)
-            {
-            	ioe.printStackTrace();
-            }
-		}
-//		System.out.printf("beforePhase: %s, for view id: %s\n",event.getPhaseId(),event.getFacesContext().getViewRoot().getViewId());
-//		dumpComponentTree(event.getFacesContext());
-	}
-
-	public PhaseId getPhaseId() {
-		return PhaseId.ANY_PHASE;
-	}
-
-	private void dumpComponentTree(final FacesContext facesContext)
-	{
-		final UIViewRoot root = facesContext.getViewRoot();
-		
-		if (root != null)
-		{
-			final String viewId = root.getViewId();
-			final ComponentInfo rootComponent = MyMonitorMessageFactory.buildComponentTree(root,false);
-			ComponentTreeMessage message = 
-				MonitorMessageFactory.createTreeMessage(viewId, rootComponent, _injectRW._rootComponentNode);
-			_socketClient.put(message);
-		}
-	}
-	
-	
-	private static class SocketClient implements Runnable
-	{
-		private final int					_port;
-		
-		private LinkedBlockingQueue<JSFMonitorMessage>  _queue = 
-			new LinkedBlockingQueue<JSFMonitorMessage>();
-		
-		SocketClient(final int port)
-		{
-			_port = port;
-		}
-		
-		public void run()
-		{
-			JSFMonitorMessage buffer = null;
-			
-			try
-			{
-				while ((buffer = _queue.take()) != null)
-				{
-			        Socket socket = null;
-			        
-			        try
-			        {
-			        	socket = new Socket("127.0.0.1", _port);
-			        	ObjectOutputStream  stream = new ObjectOutputStream(socket.getOutputStream());
-			        	stream.writeObject(buffer);
-//						PrintWriter writer = new PrintWriter(socket.getOutputStream(), true);
-//						writer.println(buffer);
-//						writer.flush();
-			        } catch (UnknownHostException e) {
-						e.printStackTrace();
-					} catch (IOException e) {
-						e.printStackTrace();
-					}
-			        finally
-			        {
-			        	if (socket != null && !socket.isClosed())
-			        	{
-			        		try {
-								socket.close();
-							} catch (IOException e) {
-								e.printStackTrace();
-							}
-			        	}
-			        }
-				}
-			}
-			catch (InterruptedException e)
-			{
-				e.printStackTrace();
-			}
-		}
-		
-		public void put(JSFMonitorMessage  message)
-		{
-			_queue.add(message);
-		}
-	}
-	
-	private static class LoggingResponseWriter extends ResponseWriter
-	{
-		private final ResponseWriter		_wrapWriter;
-		private final Stack/*<RenderNode>*/	_parentStack;
-		private RenderNode					_curNode;
-		private RenderNode					_rootComponentNode;
-
-		// map component id to the root rendernode rendered for it
-		private Map							_componentToHtml;
-		
-		LoggingResponseWriter(ResponseWriter  wrapWriter)
-		{
-			_wrapWriter = wrapWriter;
-			_parentStack = new Stack();
-			
-			_componentToHtml = new HashMap/*<String,RenderNode>*/();
-		}
-		
-		public ResponseWriter cloneWithWriter(Writer writer) {
-			return _wrapWriter.cloneWithWriter(writer);
-		}
-
-		public void endDocument() throws IOException {
-			_wrapWriter.endDocument();
-		}
-
-		public void endElement(String element) throws IOException {
-			_curNode = (RenderNode) _parentStack.pop();
-			_wrapWriter.endElement(element);
-		}
-
-		public void flush() throws IOException {
-			_wrapWriter.flush();
-		}
-
-		public String getCharacterEncoding() {
-			return _wrapWriter.getCharacterEncoding();
-		}
-
-		public String getContentType() {
-			return _wrapWriter.getContentType();
-		}
-
-		public void startDocument() throws IOException {
-			_rootComponentNode = new RenderNode(null, null);
-			_wrapWriter.startDocument();
-		}
-
-		public void startElement(String elementName, UIComponent component)
-				throws IOException 
-		{
-			String componentId = null;
-			
-			if (component != null)
-			{
-				componentId = component.getId();
-			}
-			
-			RenderNode oldNode = _curNode;
-			// push the curNode.  Pushing null indicates the root of the document
-			_parentStack.push(oldNode);
-
-			_curNode = new RenderNode(componentId, elementName);
-			
-			// note that assumption here is that the first html element
-			// we see corresponding to a component is the root of its
-			// html tree.  This may not be true if a component renders
-			// more than one root element or if the output is generated
-			// any thing but pre-order (parent first) tranversal of the 
-			// component tree.  TODO: this algorithm needs refining
-			if (!_componentToHtml.containsKey(componentId))
-			{
-				_componentToHtml.put(componentId, _curNode);
-			}
-			
-			// if the current node isn't null, then append this new element
-			if (oldNode != null)
-			{
-				oldNode.getChildren().add(_curNode);
-			}
-			// otherwise, we are at the doc root, so append there instead
-			else
-			{
-				_rootComponentNode.getChildren().add(_curNode);
-			}
-
-			
-			// do the normal write
-			_wrapWriter.startElement(elementName, component);
-		}
-
-		public void writeAttribute(String name, Object value, String componentPropertyName)
-				throws IOException {
-			
-			System.out.printf("%s: [%s,%s]\n", name, value.toString(), componentPropertyName);
-			final RenderAttribute  attribute = 
-				new RenderAttribute(name, value.toString(), componentPropertyName);
-			
-			if (_curNode != null)
-			{
-				_curNode.getRenderedAttributes().add(attribute);
-			}
-			_wrapWriter.writeAttribute(name, value, componentPropertyName);
-		}
-
-		public void writeComment(Object obj) throws IOException {
-			_wrapWriter.writeComment(obj);
-		}
-
-		public void writeText(Object arg0, String arg1) throws IOException {
-			_wrapWriter.writeText(arg0, arg1);
-		}
-
-		public void writeText(char[] arg0, int arg1, int arg2)
-				throws IOException {
-			_wrapWriter.writeText(arg0, arg1, arg2);
-		}
-
-		public void writeURIAttribute(String arg0, Object arg1, String arg2)
-				throws IOException {
-			_wrapWriter.writeURIAttribute(arg0, arg1, arg2);
-		}
-
-		public void close() throws IOException {
-			_wrapWriter.close();
-		}
-
-		public void write(char[] cbuf, int off, int len) throws IOException {
-			_wrapWriter.write(cbuf, off, len);
-		}
-
-		public ResponseWriter getWrapWriter() {
-			return _wrapWriter;
-		}
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/plugin.properties b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/plugin.properties
deleted file mode 100644
index 2279dd9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/plugin.properties
+++ /dev/null
@@ -1,11 +0,0 @@
-###############################################################################
-# Copyright (c) 2008 Oracle Corporation.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-###############################################################################
-#Properties file for org.eclipse.jst.jsf.common.runtime
-Bundle-Vendor.0 = Eclipse.org
-Bundle-Name.0 = JavaServer Faces Tools - Common Runtime
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/JSFCommonRuntimePlugin.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/JSFCommonRuntimePlugin.java
deleted file mode 100644
index 6f9d5f1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/JSFCommonRuntimePlugin.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal;
-
-import org.eclipse.core.runtime.ILog;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Plugin;
-import org.eclipse.core.runtime.Status;
-import org.osgi.framework.BundleContext;
-
-/**
- * The activator class controls the plug-in life cycle
- */
-public class JSFCommonRuntimePlugin extends Plugin {
-
-    /**
-     *  The plug-in ID
-     */
-    public static final String PLUGIN_ID = "CommonComponentPlugin"; //$NON-NLS-1$
-
-    // The shared instance
-    private static JSFCommonRuntimePlugin plugin;
-
-    /**
-     * The constructor
-     */
-    public JSFCommonRuntimePlugin() {
-        // empty constructor
-    }
-
-    /*
-     * (non-Javadoc)
-     * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)
-     */
-    public void start(final BundleContext context) throws Exception {
-        super.start(context);
-        plugin = this;
-    }
-
-    /*
-     * (non-Javadoc)
-     * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)
-     */
-    public void stop(final BundleContext context) throws Exception {
-        plugin = null;
-        super.stop(context);
-    }
-
-    /**
-     * Returns the shared instance
-     *
-     * @return the shared instance
-     */
-    public static JSFCommonRuntimePlugin getDefault() {
-        return plugin;
-    }
-
-    /**
-     * @param message
-     * @param t
-     */
-    public static void log(final String message, final Throwable t)
-    {
-        final ILog log = getDefault().getLog();
-        final IStatus status = new Status(IStatus.ERROR, PLUGIN_ID, message, t);
-        log.log(status);
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/debug/ComponentTreeMessage.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/debug/ComponentTreeMessage.java
deleted file mode 100644
index f6687f4..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/debug/ComponentTreeMessage.java
+++ /dev/null
@@ -1,246 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.debug;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentInfo;
-
-
-/**
- * Represents a component tree in message for that can be serialized.
- * 
- * @author cbateman
- *
- */
-public class ComponentTreeMessage extends JSFMonitorMessage 
-{
-    /**
-     * 
-     */
-    private static final long serialVersionUID = -6282344329821994209L;
-    private String                              _viewId;
-    private ComponentInfo                       _treeRoot;
-    private RenderNode                          _renderRoot;
-   // private HashMap<String, ComponentInfo>      _idIndex;
-    
-    /**
-     * default constructor
-     */
-    public ComponentTreeMessage()
-    {
-        //_idIndex = new HashMap<String, ComponentInfo>();
-    }
-    
-    /**
-     * @return the view id
-     */
-    public final String getViewId() {
-        return _viewId;
-    }
-
-    /**
-     * @return the componentinfo at the root of the component tree
-     */
-    public final ComponentInfo getTreeRoot() {
-        return _treeRoot;
-    }
-
-    /**
-     * @return the rendered root node
-     */
-    public final RenderNode getRenderRoot() {
-        return _renderRoot;
-    }
-
-    final void setRenderRoot(RenderNode renderRoot) {
-        _renderRoot = renderRoot;
-    }
-
-    final void setTreeRoot(ComponentInfo treeRoot)
-    {
-        _treeRoot = treeRoot;
-    }
-    
-    final void setViewId(final String viewId)
-    {
-        _viewId = viewId;
-    }
-    
-//    @Override
-//    protected void deserialize(InputStream inStream) throws IOException, ClassNotFoundException
-//    {
-//        ObjectInputStream  objectInputStream = new ObjectInputStream(inStream);
-//        
-//        Object obj = objectInputStream.readObject();
-//        int bytesRead = super.deserialize(inStream);
-//        
-//        // first line must be startView
-//        final BufferedReader reader = 
-//            new BufferedReader(new InputStreamReader(inStream));
-//        
-//        String line = reader.readLine();
-//        
-//        if (line != null
-//                && line.startsWith(START_VIEW))
-//        {
-//            _viewId = line.substring(START_VIEW.length()).trim();
-//            bytesRead += line.length()+1;
-//        }
-//        
-//        // loop until EOF
-//        while ((line = reader.readLine())!=null)
-//        {
-//            bytesRead += line.length()+1;
-//            
-//            if (line.startsWith("component:"))
-//            {
-//                parseComponent(line.substring("component:".length()).trim());
-//            }
-//            else if (line.startsWith("facet:"))
-//            {
-//                parseFacet(line.substring("facet:".length()).trim());
-//            }
-//            else if (line.startsWith("uiInput:"))
-//            {
-//                parseUIInput(line.substring("uiInput:".length()).trim());
-//            }
-//            else if (line.startsWith("uiOutput:"))
-//            {
-//                parseUIOutput(line.substring("uiOutput:".length()).trim());
-//            }
-//            else if (line.startsWith("endView"))
-//            {
-//                //
-//            }
-//        }
-//        return bytesRead;
-//    }
-
-//    private ComponentInfo  parseComponent(final String line)
-//    {
-//        final String[]  fields = line.split(",");
-//        if (fields.length >= 4)
-//        {
-//            String parentId = "!".equals(fields[0]) ? null : fields[0];
-//            String id = "!".equals(fields[1]) ? null : fields[1];
-//            String componentFamily = fields[2];
-//            String renderFamily = fields[3];
-//            
-//            ComponentInfo componentInfo = 
-//                ComponentFactory.createComponentInfo
-//                    (id, parentId, componentFamily, renderFamily);
-//
-//            if (id == null)
-//            {
-//                _treeRoot = componentInfo;
-//                _idIndex.put(null, componentInfo);
-//            }
-//            else
-//            {
-//                _idIndex.put(id, componentInfo);
-//                
-//                ComponentInfo parent = 
-//                    (ComponentInfo)_idIndex.get(parentId);
-//                
-//                if (parent != null)
-//                {
-//                    parent.getChildren().add(componentInfo);
-//                }
-//                else
-//                {
-//                    _treeRoot.getChildren().add(componentInfo);
-//                }
-//            }
-//        }
-//        return null;
-//    }
-//    
-//    private FacetInfo parseFacet(final String line)
-//    {
-//        final String[]  fields = line.split(",");
-//
-//        if (fields.length >= 4)
-//        {
-//            String parentId = "!".equals(fields[0]) ? null : fields[0];
-//            String id = "!".equals(fields[1]) ? null : fields[1];
-//            String componentFamily = fields[2];
-//            String renderFamily = fields[3];
-//
-//            FacetInfo facetInfo = 
-//                ComponentFactory.createFacetInfo(id, parentId, componentFamily, renderFamily);
-//            ComponentInfo  parent = _idIndex.get(parentId);
-//            
-//            if (parent != null)
-//            {
-//                parent.getChildren().add(facetInfo);
-//            }
-//            
-//            return facetInfo;
-//        }
-//        return null;
-//    }
-//    
-//    private UIInputInfo parseUIInput(final String line)
-//    {
-//        final String[]  fields = line.split(",");
-//
-//        if (fields.length >= 7)
-//        {
-//            String parentId = "!".equals(fields[0]) ? null : fields[0];
-//            String id = "!".equals(fields[1]) ? null : fields[1];
-//            String componentFamily = fields[2];
-//            String renderFamily = fields[3];
-//            String isValid = fields[4];
-//            String isImmediate = fields[5];
-//            String isRequired = fields[6];
-//            String isRendered = fields[7];
-//            
-//            UIInputInfo uiInputInfo = 
-//                ComponentFactory.createUIInputInfo
-//                    (id, parentId, componentFamily, renderFamily, isValid, isImmediate, isRequired, isRendered);
-//            ComponentInfo  parent = _idIndex.get(parentId);
-//            
-//            if (parent != null)
-//            {
-//                parent.getChildren().add(uiInputInfo);
-//            }
-//            
-//            return uiInputInfo;
-//        }            
-//        return null;
-//    }
-//    
-//    private UIOutputInfo parseUIOutput(final String line)
-//    {
-//        final String[]  fields = line.split(",");
-//
-//        if (fields.length >= 4)
-//        {
-//            String parentId = "!".equals(fields[0]) ? null : fields[0];
-//            String id = "!".equals(fields[1]) ? null : fields[1];
-//            String componentFamily = fields[2];
-//            String renderFamily = fields[3];
-//            String isRendered = fields[4];
-//            
-//            UIOutputInfo uiOutputInfo = 
-//                ComponentFactory.createUIOutputInfo(id, parentId, componentFamily, renderFamily, isRendered);
-//            
-//            ComponentInfo  parent = _idIndex.get(parentId);
-//            
-//            if (parent != null)
-//            {
-//                parent.getChildren().add(uiOutputInfo);
-//            }
-//            
-//            return uiOutputInfo;
-//        }            
-//        return null;
-//    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/debug/JSFMonitorMessage.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/debug/JSFMonitorMessage.java
deleted file mode 100644
index 4b2be53..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/debug/JSFMonitorMessage.java
+++ /dev/null
@@ -1,26 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.debug;
-
-import java.io.Serializable;
-
-/**
- * Super of all messages that are sent by the JSF debug monitor
- * @author cbateman
- *
- */
-public abstract class JSFMonitorMessage implements Serializable
-{
-    /**
-     * 
-     */
-    private static final long serialVersionUID = -5417558019077000040L;
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/debug/MonitorMessageFactory.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/debug/MonitorMessageFactory.java
deleted file mode 100644
index eb57677..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/debug/MonitorMessageFactory.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.debug;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentInfo;
-
-/**
- * Creates JSF remote monitor messages.
- * 
- * @author cbateman
- *
- */
-public class MonitorMessageFactory 
-{
-    /**
-     * @param viewId
-     * @param root
-     * @param renderRoot
-     * @return a new component tree message for the parameters
-     */
-    public static ComponentTreeMessage createTreeMessage(final String viewId, final ComponentInfo root, final RenderNode renderRoot)
-    {
-        ComponentTreeMessage message = new ComponentTreeMessage();
-        message.setViewId(viewId);
-        message.setTreeRoot(root);
-        message.setRenderRoot(renderRoot);
-        return message;
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/debug/RenderAttribute.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/debug/RenderAttribute.java
deleted file mode 100644
index e0c1b91..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/debug/RenderAttribute.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.debug;
-
-/**
- * Information about a rendered XML attribute
- * 
- * @author cbateman
- *
- */
-public class RenderAttribute extends JSFMonitorMessage {
-
-    /**
-     * 
-     */
-    private static final long serialVersionUID = -4601065346261130623L;
-
-    private final String  _name;        // the name of the attribute.  TODO: local vs. namespace?
-    private final String  _value;       // the rendered value of the  node
-    private final String  _propertyName;  // the property name on the corresponding component
-                                          // may be null
-    /**
-     * @param name
-     * @param value
-     * @param propertyName
-     */
-    public RenderAttribute(String name, String value, String propertyName) {
-        super();
-        _name = name;
-        _propertyName = propertyName;
-        _value = value;
-    }
-    /**
-     * @return the name of the attribute
-     */
-    public final String getName() {
-        return _name;
-    }
-    /**
-     * @return the attribute's value
-     */
-    public final String getValue() {
-        return _value;
-    }
-    /**
-     * @return the name of the corresponding component property if any.
-     */
-    public final String getPropertyName() {
-        return _propertyName;
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/debug/RenderNode.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/debug/RenderNode.java
deleted file mode 100644
index 2679c62..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/debug/RenderNode.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.debug;
-
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-
-/**
- * A rendered XML node.
- * 
- * @author cbateman
- *
- */
-public class RenderNode extends JSFMonitorMessage 
-{
-    /**
-     * 
-     */
-    private static final long serialVersionUID = -2843929405836710015L;
-
-    private final String      _componentId;       // the id of the component id that caused the node to render
-    private final String      _renderedNodeName;  // the node
-    private final List/*<RenderedAttribute>*/        _renderedAttributes; // attributes
-    private final List        _children;          // the rendered children of renderedNode based
-                                                  // on the output document hiearchy
-    /**
-     * @param componentId
-     * @param renderedNodeName
-     */
-    public RenderNode(String componentId, String renderedNodeName) {
-        super();
-        _componentId = componentId;
-        _renderedNodeName = renderedNodeName;
-        
-        _children = new ArrayList();
-        _renderedAttributes = new ArrayList();
-    }
-    /**
-     * @return the corresponding component's id
-     */
-    public final String getComponentId() {
-        return _componentId;
-    }
-    /**
-     * @return the node's children
-     */
-    public final List getChildren() {
-        return _children;
-    }
-    /**
-     * @return the name of the rendered node (element)
-     */
-    public final String getRenderedNodeName() {
-        return _renderedNodeName;
-    }
-    /**
-     * @return the attributes of this node as rendered.
-     */
-    public final List getRenderedAttributes() {
-        return _renderedAttributes;
-    }
-    public String toString()
-    {
-        String toString = "Root node: "+_renderedNodeName+", attributes: ["; //$NON-NLS-1$ //$NON-NLS-2$
-        
-        for (Iterator it = _renderedAttributes.iterator(); it.hasNext();)
-        {
-            final RenderAttribute attribute = (RenderAttribute) it.next();
-            toString+=attribute.getName() + "=" + attribute.getValue(); //$NON-NLS-1$
-            
-            toString+=it.hasNext() ? ", " : "]"; //$NON-NLS-1$ //$NON-NLS-2$
-        }
-        
-        return toString;
-    }
-}
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/IDesigntimeAdapter.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/IDesigntimeAdapter.java
deleted file mode 100644
index bd427e6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/IDesigntimeAdapter.java
+++ /dev/null
@@ -1,26 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model;
-
-/**
- * Implemented by design time adapters that represent runtime interfaces.
- * 
- * @author cbateman
- *
- */
-public interface IDesigntimeAdapter
-{
-    /**
-     * @return the list of runtime interfaces that this runtime adapter 
-     * represents.
-     */
-    String[]  getInterfaces();
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/ViewObject.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/ViewObject.java
deleted file mode 100644
index 9c36f72..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/ViewObject.java
+++ /dev/null
@@ -1,542 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.Decorator;
-
-/**
- * The base type of all objects that participate in the lifecycle of a view.
- * This may be used to hold either design time or runtime information.
- * 
- * @author cbateman
- * 
- */
-public abstract class ViewObject implements Serializable /* IAdaptable? */
-{
-    private final ViewObjectData    _data;
-
-    /**
-     * 
-     */
-    private static final long serialVersionUID = 1592205691642453075L;
-
-    /**
-     * 
-     */
-    protected ViewObject()
-    {
-        this(new ViewObjectData(false));
-    }
-
-    /**
-     * @param delegate
-     */
-    protected ViewObject(final ViewObjectData delegate)
-    {
-        _data = delegate;
-        _data.setOwner(this);
-    }
-
-    /**
-     * @return the object containing all this view object's data
-     */
-    protected ViewObjectData getData()
-    {
-        return _data;
-    }
-
-    /**
-     * IMPORTANT: if this method returns false, then calling a mutator method
-     * (basically anything that is not a get/isX() will throw any
-     * IllegalStateException).
-     * 
-     * @return if the object can still be modified.
-     */
-    public final boolean isModifiable()
-    {
-        return !getData().isProtected();
-    }
-
-    /**
-     * Calling this method sets the state to not modifiable
-     */
-    public final void setProtected()
-    {
-        getData().setLocked();
-    }
-
-    /**
-     * This call may be create a new data structure and should be considered of
-     * much higher cost than most calls.
-     * 
-     * @return all decorators of this object. List should be assumed by clients
-     *         to be unmodifiable and may throw mutation exceptions
-     */
-    public List getAllDecorators()
-    {
-        final int size = getDecoratorMap().size();
-
-        if (size == 0)
-        {
-            return Collections.EMPTY_LIST;
-        }
-
-        final List allDecorators = new ArrayList();
-        for (final Iterator entryIt = getDecoratorMap().entrySet().iterator(); entryIt
-        .hasNext();)
-        {
-            final Map.Entry entry = (Map.Entry) entryIt.next();
-            final List decorators = (List) entry.getValue();
-            allDecorators.addAll(decorators);
-        }
-
-        return Collections.unmodifiableList(allDecorators);
-    }
-
-    /**
-     * @param decoratorType
-     * @return all decorators of this object associated with the class type. The
-     *         returned list should be assumed to be unmodifiable. Returns an
-     *         empty list if no decorators are associated with decoratorType
-     */
-    public List getDecorators(final Class decoratorType)
-    {
-        final List decorators = (List) getDecoratorMap().get(decoratorType);
-
-        if (decorators == null)
-        {
-            return Collections.EMPTY_LIST;
-        }
-        return Collections.unmodifiableList(decorators);
-    }
-
-    /**
-     * Add the decorator using decorator.getClass to associate the type. Must be
-     * equivalent to addDecorator(decorator, decorator.getClass());
-     * 
-     * @param decorator
-     *            the decorator to add. <b>Must NOT be null.</b>
-     * @throws IllegalArgumentException
-     *             if decorator is null.
-     */
-    public void addDecorator(final Decorator decorator)
-    {
-        _data.addDecorator(decorator);
-    }
-
-    /**
-     * Add the decorator using the associatedType. Normally you should call
-     * {@link #addDecorator(Decorator)} however in some cases you may wish to
-     * associated a decorator with a class type other than its own. For example,
-     * sub-classes of ValidatorDecorator will want to associated with
-     * ValidatorDecorator.getClass() in most cases so that it is included in any
-     * common examination of component validators.
-     * 
-     * @param decorator
-     *            to add. <b>Must NOT be null.</b>
-     * @param associatedType
-     *            the key to store decorator <b>Must NOT be null</b>
-     * @throws IllegalArgumentException
-     *             if decorator or associatedType is null
-     */
-    public void addDecorator(final Decorator decorator,
-            final Class associatedType)
-    {
-        _data.addDecorator(decorator, associatedType);
-    }
-
-    /**
-     * Removes decorator if it is associated to associatedType on this view
-     * object.
-     * 
-     * @param decorator
-     * @param associatedType
-     * @return true if the decorator was found and removed.
-     * @throws IllegalArgumentException
-     *             if decorator or associatedType is null
-     */
-    public boolean removeDecorator(final Decorator decorator,
-            final Class associatedType)
-    {
-        return _data.removeDecorator(decorator, associatedType);
-    }
-
-    /**
-     * <p>
-     * Get the adapter associated the class key.
-     * </p>
-     * 
-     * <p>
-     * If addAdapter has been called with adapterType, then this adapter object
-     * should always be called. In the default implementation, if there is no
-     * explicit adapter, "this" is returned if (this instanceof adapterType).
-     * 
-     * @param adapterType
-     * @return the interface adapter associated with the class key or null if
-     *         not found
-     */
-    public Object getAdapter(final Class adapterType)
-    {
-        if (adapterType == null)
-        {
-            return null;
-        }
-
-        Object adapter = getAdapterMap().get(adapterType);
-
-        if (adapter == null)
-        {
-            if (adapterType.isInstance(this))
-            {
-                adapter = this;
-            }
-        }
-
-        return adapter;
-    }
-
-    /**
-     * Adds the interface adapter object under adapterType key. There can be at
-     * most one adapter registered for each class key.
-     * 
-     * It is an error (throws exception) to try to add an adapter for
-     * adapterType which this is already instance. This restriction is necessary
-     * because otherwise local getters/setters would need to be aware of the
-     * adapter mechanism and verify inheritance hierarchies on every calls. This
-     * mechanism is intended only for adding interfaces to view object impls
-     * that don't already have them.
-     * 
-     * @param adapterType
-     * @param adapter
-     * @throws IllegalArgumentException
-     *             if adapterType or adapter is null or if casting adapter to
-     *             adapterType would * cause a ClassCastException (i.e. if
-     *             !(adapter instanceof adapterType)) OR if this is already an
-     *             instance of adapterType.
-     */
-    public void addAdapter(final Class adapterType, final Object adapter)
-    {
-        _data.addAdapter(adapterType, adapter);
-    }
-
-    /**
-     * Note that {@link #getAdapter(Class)} may still return non-null after this
-     * is called if (this instanceof adapterType).
-     * 
-     * @param adapterType
-     * @return the adapter for adapterType that was just removed or null if not
-     *         found
-     */
-    public Object removeAdapter(final Class adapterType)
-    {
-        return getAdapterMap().remove(adapterType);
-    }
-
-    /**
-     * Note that this only returns those adapters added using
-     * {@link #addAdapter(Class, Object)}. It does not return any implicit
-     * adapters resulting from (this instanceof type).
-     * 
-     * @return the map of all adapters. Maps is immutable and may throw
-     *         exceptions on attempts to mutate.
-     */
-    public Map getAllAdapters()
-    {
-        if (getAdapterMap().size() == 0)
-        {
-            return Collections.EMPTY_MAP;
-        }
-        return Collections.unmodifiableMap(getAdapterMap());
-    }
-
-    /**
-     * <p>
-     * The contract for this method is that it must always return a usable Map
-     * and that map must be the same on every call. Lazy construction may be
-     * used (as it is by default). The default map size is 4 and load factor is
-     * 3 meaning that there should be decent tradeoff between wasted table size
-     * and overhead used to increase it should the number of decorators exceed
-     * 3. <b>Must never return null.</b>
-     * </p>
-     * 
-     * <p>
-     * Generally, the method should not need to be overridden, however it is
-     * provided to allow sub-classes to change the way the decorators map is
-     * constructed.
-     * </p>
-     * 
-     * @return the map containing lists of decorators keyed by class.
-     * 
-     */
-    protected Map getDecoratorMap()
-    {
-        return _data.getDecoratorMap();
-    }
-
-    /**
-     * <p>
-     * The contract for this method is that it must always return a usable Map
-     * and that map must be the same on every call. Lazy construction may be
-     * used (as it is by default). The default map size is 4 and load factor is
-     * 3 meaning that there should be decent tradeoff between wasted table size
-     * and overhead used to increase it should the number of decorators exceed
-     * 3. <b>Must never return null.</b>
-     * </p>
-     * 
-     * <p>
-     * Generally, the method should not need to be overridden, however it is
-     * provided to allow sub-classes to change the way the decorators map is
-     * constructed.
-     * </p>
-     * 
-     * @return the map containing lists of adapters keyed by class.
-     * 
-     */
-    protected Map getAdapterMap()
-    {
-        return _data.getAdapterMap();
-    }
-
-    // ALL ViewObject's must use reference equals
-    public final boolean equals(final Object obj)
-    {
-        return super.equals(obj);
-    }
-
-    public final int hashCode()
-    {
-        return super.hashCode();
-    }
-
-    /**
-     * The protectable view object data.
-     * 
-     */
-    public static class ViewObjectData extends ProtectedDataObject
-    {
-        /**
-         * 
-         */
-        private static final long serialVersionUID = -4216980607447926035L;
-        private Map _decorators;
-        private Map _adapters;
-        private Object _owner;
-
-        /**
-         * @param isProtected
-         */
-        public ViewObjectData(final boolean isProtected)
-        {
-            super(isProtected);
-        }
-
-        private void setOwner(final ViewObject viewObject)
-        {
-            _owner = viewObject;
-        }
-
-        /**
-         * For serialization only.
-         */
-        //        public ViewObjectData()
-        //        {
-        //            // for serializability
-        //            super(false);
-        //        }
-
-        /**
-         * @param decorator
-         * @param associatedType
-         * @return true if the decorator was removed.
-         */
-        public boolean removeDecorator(final Decorator decorator, final Class associatedType)
-        {
-            enforceProtection();
-
-            if (decorator == null || associatedType == null)
-            {
-                throw new IllegalArgumentException("Arguments must not be null"); //$NON-NLS-1$
-            }
-
-            final List decoratorsByType = (List) getDecoratorMap().get(
-                    associatedType);
-
-            if (decoratorsByType != null)
-            {
-                return decoratorsByType.remove(decorator);
-            }
-
-            return false;
-        }
-
-        /**
-         * @param adapterType
-         * @param adapter
-         */
-        public void addAdapter(final Class adapterType, final Object adapter)
-        {
-            enforceProtection();
-
-            if (adapterType == null || adapter == null)
-            {
-                throw new IllegalArgumentException("Arguments must not be null"); //$NON-NLS-1$
-            }
-
-            if (!adapterType.isInstance(adapter))
-            {
-                throw new IllegalArgumentException("adapter: " + adapter //$NON-NLS-1$
-                        + " must be cast compatible to class: " + adapterType); //$NON-NLS-1$
-            }
-            else if (adapterType.isInstance(_owner))
-            {
-                throw new IllegalArgumentException("this: " + _owner //$NON-NLS-1$
-                        + " must not already be an instance of class: " //$NON-NLS-1$
-                        + adapterType);
-            }
-            getAdapterMap().put(adapterType, adapter);
-        }
-
-        /**
-         * @param decorator
-         */
-        public void addDecorator(final Decorator decorator)
-        {
-            enforceProtection();
-
-            if (decorator == null)
-            {
-                throw new IllegalArgumentException("Arguments must not be null"); //$NON-NLS-1$
-            }
-            final Class associationType = decorator.getClass();
-            addDecorator(decorator, associationType);
-        }
-
-        /**
-         * @param decorator
-         * @param associatedType
-         */
-        public void addDecorator(final Decorator decorator, final Class associatedType)
-        {
-            enforceProtection();
-
-            if (decorator == null || associatedType == null)
-            {
-                throw new IllegalArgumentException("Arguments must not be null"); //$NON-NLS-1$
-            }
-
-            List decoratorsByType = (List) getDecoratorMap().get(associatedType);
-
-            if (decoratorsByType == null)
-            {
-                decoratorsByType = new ArrayList(2);
-                getDecoratorMap().put(associatedType, decoratorsByType);
-            }
-
-            decoratorsByType.add(decorator);
-        }
-
-        /**
-         * @return the decorator map, creating it if necessary
-         */
-        protected synchronized Map getDecoratorMap()
-        {
-            if (_decorators == null)
-            {
-                if (isProtected())
-                {
-                    _decorators = Collections.EMPTY_MAP;
-                }
-                _decorators = new HashMap(4);
-            }
-            return _decorators;
-        }
-
-        /**
-         * @return the adapter map, creating if necessary.
-         */
-        protected synchronized Map getAdapterMap()
-        {
-            if (_adapters == null)
-            {
-                _adapters = new HashMap(4);
-            }
-
-            return _adapters;
-        }
-    }
-
-    /**
-     * An object that enforces that mutation can only happen up to point where
-     * the object is designated protected at which point is it is forever
-     * immutable.
-     * 
-     */
-    public static abstract class ProtectedDataObject implements Serializable
-    {
-        /**
-         * 
-         */
-        private static final long serialVersionUID = 4470279408370430399L;
-        private boolean _isProtected;
-
-        /**
-         * @param isProtected
-         */
-        public ProtectedDataObject(final boolean isProtected)
-        {
-            _isProtected = isProtected;
-        }
-
-        /**
-         * @throws UnsupportedOperationException
-         */
-        protected final synchronized void enforceProtection() throws UnsupportedOperationException
-        {
-            if (isProtected())
-            {
-                throw new UnsupportedOperationException("Object "+this.toString()+ " is locked for modification"); //$NON-NLS-1$ //$NON-NLS-2$
-            }
-        }
-
-        /**
-         * @return true if this object is protected and irrevocablly immutable.
-         */
-        public final synchronized boolean isProtected()
-        {
-            return _isProtected;
-        }
-
-        /**
-         * Executed right before setProtected irrevocably sets the protection
-         * flag. Does nothing by default
-         */
-        protected void doBeforeProtecting()
-        {
-            // do nothing by default
-        }
-        /**
-         * Makes this object irrevocably immutable.
-         */
-        public final synchronized void setLocked()
-        {
-            doBeforeProtecting();
-            _isProtected = true;
-        }
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/bean/DataModelInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/bean/DataModelInfo.java
deleted file mode 100644
index e7c2e93..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/bean/DataModelInfo.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.bean;
-
-import java.io.Serializable;
-
-/**
- * Design time analog of runtime DataModel bean
- * 
- * @author cbateman
- *
- */
-public class DataModelInfo implements Serializable 
-{
-    /**
-     * serializable id
-     */
-    private static final long serialVersionUID = 6461056497382677871L;
-
-    private final boolean               _rowAvailable;
-    private final int                   _rowCount;
-    private final SerializableObject    _rowData;
-    private final int                   _rowIndex;
-    private final SerializableObject    _wrappedData;
-
-    /**
-     * @param rowAvailable
-     * @param rowCount
-     * @param rowData
-     * @param rowIndex
-     * @param wrappedData
-     */
-    public DataModelInfo(boolean rowAvailable, int rowCount, Object rowData,
-            int rowIndex, Object wrappedData) {
-        super();
-        _rowAvailable = rowAvailable;
-        _rowCount = rowCount;
-        _rowData = new SerializableObject(rowData);
-        _rowIndex = rowIndex;
-        _wrappedData = new SerializableObject(wrappedData);
-    }
-
-    /**
-     * @return true if the current row is available
-     */
-    public final boolean isRowAvailable() {
-        return _rowAvailable;
-    }
-    /**
-     * @return the row count of this model
-     */
-    public final int getRowCount() {
-        return _rowCount;
-    }
-    /**
-     * @return the row data
-     */
-    public final Object getRowData() {
-        return _rowData.getMaybeSerializable();
-    }
-    /**
-     * @return the row index
-     */
-    public final int getRowIndex() {
-        return _rowIndex;
-    }
-    /**
-     * @return the wrapped data.  may be null if wrapped object was not
-     * serializable.
-     */
-    public final Object getWrappedData() {
-        return _wrappedData.getMaybeSerializable();
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/bean/SerializableObject.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/bean/SerializableObject.java
deleted file mode 100644
index e3b066a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/bean/SerializableObject.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.bean;
-
-import java.io.IOException;
-import java.io.NotSerializableException;
-import java.io.Serializable;
-
-/**
- * A special object used in place of Object to ensure that when an interface
- * requires a generic #{@link java.lang.Object}, it won't throw serialization
- * exception when a containing object is serialized.
- * 
- * @author cbateman
- * 
- */
-public class SerializableObject implements Serializable
-{
-    /**
-     * 
-     */
-    private static final long serialVersionUID = 9133733048469500692L;
-    private Object      _maybeSerializable;
-    
-    /**
-     * @param maybeSerializable
-     */
-    public SerializableObject(Object maybeSerializable)
-    {
-        _maybeSerializable = maybeSerializable;
-    }
-    
-    
-//    /**
-//     * Provided to support serialization.  Should not be used by sub-classes
-//     * or clients except in this regard.
-//     */
-//    protected SerializableObject()
-//    {
-//        _maybeSerializable = null;
-//    }
-    
-    /**
-     * @return the actual value
-     */
-    public final Object getMaybeSerializable() {
-        return _maybeSerializable;
-    }
-
-
-    private void writeObject(java.io.ObjectOutputStream out)
-        throws IOException
-    {
-        try
-        {
-            out.writeObject(_maybeSerializable);
-        }
-        catch (NotSerializableException nse)
-        {
-            // do nothing, the object isn't guaranteed to be serializable,
-            // but we don't want this be an error
-            out.writeObject(null);
-        }
-    }
-    
-    private void readObject(java.io.ObjectInputStream in)
-        throws IOException, ClassNotFoundException
-    {
-        _maybeSerializable = in.readObject();
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/ActionSourceInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/ActionSourceInfo.java
deleted file mode 100644
index 6e7348d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/ActionSourceInfo.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.behavioural;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.IDesigntimeAdapter;
-import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentFactory;
-import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ActionListenerDecorator;
-
-/**
- * Implementation of the ActionSourceInfo.
- * 
- * @author cbateman
- *
- */
-public class ActionSourceInfo implements IActionSourceInfo, IDesigntimeAdapter
-{
-    /**
-     * serializable id
-     */
-    private static final long serialVersionUID = 6531166406473466685L;
-    private static final String[]                INTERFACE = new String[]{ComponentFactory.INTERFACE_ACTIONSOURCE};
-    private final String                                    _action;
-    private final String                                    _actionListener;
-    private final boolean                                   _immediate;
-    private List/*<ActionListenerDecorator>*/               _actionListeners;
-    
-    /**
-     * @param action
-     * @param actionListener
-     * @param immediate
-     */
-    public ActionSourceInfo(final String action, final String actionListener,
-            final boolean immediate) 
-    {
-        super();
-        _action = action;
-        _actionListener = actionListener;
-        _immediate = immediate;
-    }
-
-    public void addActionListener(final ActionListenerDecorator actionListener) {
-        if (_actionListeners == null)
-        {
-            _actionListeners = new ArrayList(2);
-        }
-        _actionListeners.add(actionListener);
-    }
-
-    public String getAction() {
-        return _action;
-    }
-
-    public String getActionListener() {
-        return _actionListener;
-    }
-
-    public List getActionListeners() {
-        if (_actionListeners == null)
-        {
-            return Collections.EMPTY_LIST;
-        }
-        return Collections.unmodifiableList(_actionListeners);
-    }
-
-    public boolean isImmediate() {
-        return _immediate;
-    }
-
-    public String[] getInterfaces()
-    {
-        return INTERFACE;
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/ActionSourceInfo2.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/ActionSourceInfo2.java
deleted file mode 100644
index d36b95b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/ActionSourceInfo2.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.behavioural;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.IDesigntimeAdapter;
-import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentFactory;
-
-/**
- * Implementation of the IActionSource2Info
- * 
- * @author cbateman
- *
- */
-public class ActionSourceInfo2 extends ActionSourceInfo implements
-        IActionSource2Info, IDesigntimeAdapter
-{
-    /**
-     * serializable id
-     */
-    private static final long serialVersionUID = 5811194815559772378L;
-    private static final String[]                INTERFACE = new String[]{ComponentFactory.INTERFACE_ACTIONSOURCE2};
-
-    private final String        _actionExpression;
-    
-    /**
-     * @param action
-     * @param actionListener
-     * @param immediate
-     * @param actionExpression
-     */
-    public ActionSourceInfo2(final String action, final String actionListener,
-            final boolean immediate, final String actionExpression) {
-        super(action, actionListener, immediate);
-        _actionExpression = actionExpression;
-    }
-
-    public String getActionExpression() {
-        return _actionExpression;
-    }
-
-    public String[] getInterfaces()
-    {
-        return INTERFACE;
-    }
-    
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/EditableValueHolderInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/EditableValueHolderInfo.java
deleted file mode 100644
index 8b07c45..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/EditableValueHolderInfo.java
+++ /dev/null
@@ -1,144 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.behavioural;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.IDesigntimeAdapter;
-import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentFactory;
-import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ConverterDecorator;
-import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ValidatorDecorator;
-import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ValueChangeListenerDecorator;
-
-/**
- * Implementation of the IEditableValueHolderInfo
- * 
- * @author cbateman
- *
- */
-public class EditableValueHolderInfo extends ValueHolderInfo implements
-        IEditableValueHolderInfo, IDesigntimeAdapter
-{
-    /**
-     * 
-     */
-    private static final long serialVersionUID = -2115990809157328451L;
-    private static final String[]  INTERFACE = new String[] {ComponentFactory.INTERFACE_EDITABLEVALUEHOLDER};
-    
-    private final boolean       _localSetValue;
-    private final Object        _submittedValue;
-    private final String        _validator;
-    private final String        _valueChangeListener;
-    private final boolean       _isImmediate;
-    private final boolean       _isRequired;
-    private final boolean       _isValid;
-    private List                _validators;
-    private List                _valueChangeListeners;
-    
-    /**
-     * @param converterDecorator
-     * @param localValue
-     * @param value
-     * @param isImmediate
-     * @param isRequired
-     * @param isValid
-     * @param localSetValue
-     * @param submittedValue
-     * @param validator
-     * @param valueChangeListener
-     */
-    public EditableValueHolderInfo(final ConverterDecorator converterDecorator,
-            final Object localValue, final Object value, final boolean isImmediate,
-            final boolean isRequired, final boolean isValid, final boolean localSetValue,
-            final Object submittedValue, final String validator, final String valueChangeListener) 
-    {
-        super(converterDecorator, localValue, value);
-        _isImmediate = isImmediate;
-        _isRequired = isRequired;
-        _isValid = isValid;
-        _localSetValue = localSetValue;
-        _submittedValue = submittedValue;
-        _validator = validator;
-        _valueChangeListener = valueChangeListener;
-    }
-
-    public final boolean isLocalSetValue() {
-        return _localSetValue;
-    }
-
-    public final Object getSubmittedValue() {
-        return _submittedValue;
-    }
-
-    public final String getValidator() {
-        return _validator;
-    }
-
-    public final String getValueChangeListener() {
-        return _valueChangeListener;
-    }
-
-    public final boolean isImmediate() {
-        return _isImmediate;
-    }
-
-    public final boolean isRequired() {
-        return _isRequired;
-    }
-
-    public final boolean isValid() {
-        return _isValid;
-    }
-
-    public void addValidator(final ValidatorDecorator validator) 
-    {
-        if (_validators == null)
-        {
-            _validators = new ArrayList(2);
-        }
-        _validators.add(validator);
-    }
-
-    public void addValueChangeListener(
-            final ValueChangeListenerDecorator valueChangeListenerInfo) 
-    {
-        if (_valueChangeListeners == null)
-        {
-            _valueChangeListeners = new ArrayList(2);
-        }
-        _valueChangeListeners.add(valueChangeListenerInfo);
-    }
-
-    public List getValidators() {
-        if (_validators == null)
-        {
-            return Collections.EMPTY_LIST;
-        }
-        
-        return Collections.unmodifiableList(_validators);
-    }
-
-    public List getValueChangeListeners() {
-        if (_valueChangeListeners == null)
-        {
-            return Collections.EMPTY_LIST;
-        }
-        
-        return Collections.unmodifiableList(_valueChangeListeners);
-    }
-
-    public String[] getInterfaces()
-    {
-        return INTERFACE;
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/IActionSource2Info.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/IActionSource2Info.java
deleted file mode 100644
index 21966e1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/IActionSource2Info.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.behavioural;
-
-/**
- * Design-time analog for the ActionSource2 interface.
- * 
- * @author cbateman
- *
- */
-public interface IActionSource2Info extends IActionSourceInfo 
-{
-    /**
-     * TODO: this method is similar to getAction on ActionSource from
-     * our perspective since the actual string rep of the EL is basically
-     * the same...
-     * 
-     * @return an EL method expression that represents a call to 
-     * an action method.
-     */
-    String getActionExpression();
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/IActionSourceInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/IActionSourceInfo.java
deleted file mode 100644
index 3d2dd2e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/IActionSourceInfo.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.behavioural;
-
-import java.io.Serializable;
-import java.util.List;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ActionListenerDecorator;
-
-/**
- * A design time analog for the runtime ActionSource interface.
- * 
- * @author cbateman
- *
- */
-public interface IActionSourceInfo extends Serializable
-{
-    /**
-     * @return true if action listener associated with this action source
-     * should be executed immediately after the apply request values phase.
-     * Default is false.
-     */
-    boolean isImmediate();
-    
-    
-    /**
-     * Add the action listener to the list
-     * 
-     * @param actionListener
-     */
-    void addActionListener(ActionListenerDecorator  actionListener);
-    
-    /**
-     * @return all action listeners registered.  List should be considered
-     * immutable and may throw exceptions if modified.
-     */
-    List/*<ActionListenerDecorator>*/ getActionListeners();
-    
-    /**
-     * <b> NOTE: this method is deprecated in the runtime spec and exists for
-     * backward compatibility with JSF 1.1. You should avoid using it except in
-     * conjunction with JSF 1.1 tooling support. This method will be deprecated
-     * once the runtime spec removes the underlying API</b>
-
-     * @return a method binding expression describing an action handler
-     */
-    String  getAction();
-    
-    /**
-     * <b> NOTE: this method is deprecated in the runtime spec and exists for
-     * backward compatibility with JSF 1.1. You should avoid using it except in
-     * conjunction with JSF 1.1 tooling support. This method will be deprecated
-     * once the runtime spec removes the underlying API</b>
-     * 
-     * @return a method binding expression describing an action listener
-     */
-    String  getActionListener();
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/IEditableValueHolderInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/IEditableValueHolderInfo.java
deleted file mode 100644
index 53403d1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/IEditableValueHolderInfo.java
+++ /dev/null
@@ -1,103 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.behavioural;
-
-import java.util.List;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ValidatorDecorator;
-import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ValueChangeListenerDecorator;
-
-/**
- * A design time analog for the JSF runtime EditableValueHolder interface.
- * 
- * @author cbateman
- * 
- */
-public interface IEditableValueHolderInfo extends IValueHolderInfo {
-    /**
-     * @return the flag indicating whether the value of the value holder should
-     *         be evaluated in the apply request values phase instead of the
-     *         process validations phase
-     */
-    boolean isImmediate();
-
-    /**
-     * @return true if the value has been set
-     */
-    boolean isLocalSetValue();
-
-    /**
-     * @return true if validation should consider this field required (must be
-     *         non-empty).
-     */
-    boolean isRequired();
-
-    /**
-     * @return the submitted, unconverted value of the component.
-     */
-    Object getSubmittedValue();
-
-    /**
-     * @return false if validation has determined that the value property of
-     *         this component is not valid.
-     */
-    boolean isValid();
-
-    /**
-     * <b> NOTE: this method is deprecated in the runtime spec and exists for
-     * backward compatibility with JSF 1.1. You should avoid using it except in
-     * conjunction with JSF 1.1 tooling support. This method will be deprecated
-     * once the runtime spec removes the underlying API</b>
-     * 
-     * @return a method binding expression that refers to a validator method
-     */
-    String getValidator();
-
-    /**
-     * <b> NOTE: this method is deprecated in the runtime spec and exists for
-     * backward compatibility with JSF 1.1. You should avoid using it except in
-     * conjunction with JSF 1.1 tooling support. This method will be deprecated
-     * once the runtime spec removes the underlying API</b>
-     * 
-     * @return a method binding expression that refers to a value change
-     *         listener
-     */
-    String getValueChangeListener();
-
-    /**
-     * Add validator to the list of validators for this component. Should be
-     * equivalent to
-     * {@link org.eclipse.jst.jsf.common.runtime.internal.model.ViewObject#addDecorator(org.eclipse.jst.jsf.common.runtime.internal.model.decorator.Decorator, Class)}.
-     * 
-     * @param validator
-     */
-    void addValidator(ValidatorDecorator validator);
-
-    /**
-     * @return the list of validators for this component. Should be considered
-     *         unmodifiable (may throw exception).
-     */
-    List/* <ValidatorDecorator> */getValidators();
-
-    /**
-     * Add the value change listener to this component.
-     * 
-     * @param valueChangeListenerInfo
-     */
-    void addValueChangeListener(
-            ValueChangeListenerDecorator valueChangeListenerInfo);
-
-    /**
-     * @return the list of value change listeners. Should be considered
-     *         unmodifiable (may throw exception).
-     */
-    List/* <ValueChangeListenerDecorator> */getValueChangeListeners();
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/INamingContainerInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/INamingContainerInfo.java
deleted file mode 100644
index aeb1e98..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/INamingContainerInfo.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.behavioural;
-
-import java.io.Serializable;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.IDesigntimeAdapter;
-import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentFactory;
-
-/**
- * Design time analog for the NamingContainer interface.
- * 
- * @author cbateman
- * 
- */
-public interface INamingContainerInfo extends Serializable
-{
-    // tagging interface
-
-    /**
-     * Used as an adapter impl
-     */
-    public final static INamingContainerInfo ADAPTER = new NamingContainerInfo();
-    
-    /**
-     * A default naming container info
-     * @author cbateman
-     *
-     */
-    public static class NamingContainerInfo implements INamingContainerInfo, IDesigntimeAdapter
-    {
-        /**
-         * 
-         */
-        private static final long serialVersionUID = 7214529928361444126L;
-
-        public String[] getInterfaces()
-        {
-            return new String[] {ComponentFactory.INTERFACE_NAMINGCONTAINER};
-        }
-        
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/IValueHolderInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/IValueHolderInfo.java
deleted file mode 100644
index 661dd81..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/IValueHolderInfo.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.behavioural;
-
-import java.io.Serializable;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ConverterDecorator;
-
-/**
- * Represents design time information about the ValueHolder behavioural
- * interface.
- * 
- * @author cbateman
- *
- */
-public interface IValueHolderInfo extends Serializable
-{
-    /**
-     * @return the value, may be null
-     */
-    Object getValue();
-    
-    /**
-     * @return the raw value without expression value evaluation.  Note that 
-     * {@link #getValue()} may return the same value in cases where this value
-     * holder is derived at design time without EL expression evaluation. May be null.
-     */
-    Object getLocalValue();
-    
-    /**
-     * @return the converter for this value holder or null if none.
-     */
-    ConverterDecorator getConverter();
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/ValueHolderInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/ValueHolderInfo.java
deleted file mode 100644
index 25c8e2e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/behavioural/ValueHolderInfo.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.behavioural;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.IDesigntimeAdapter;
-import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentFactory;
-import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ConverterDecorator;
-
-/**
- * Implementation of the IValueHolderInfo.
- * 
- * @author cbateman
- *
- */
-public class ValueHolderInfo implements IValueHolderInfo, IDesigntimeAdapter
-{
-    /**
-     * 
-     */
-    private static final long serialVersionUID = 5000699728360703727L;
-
-    /**
-     * the value (may include EL evaluation)
-     */
-    protected final Object                  _value;
-    /**
-     * the raw value  before EL evaluation.
-     */
-    protected final Object                  _localValue;
-    /**
-     * the converter or null if none.
-     */
-    protected final ConverterDecorator      _converterDecorator;
-    
-    /**
-     * @param converterDecorator
-     * @param localValue
-     * @param value
-     */
-    public ValueHolderInfo(final ConverterDecorator converterDecorator,
-            final Object localValue, final Object value) {
-        super();
-        _converterDecorator = converterDecorator;
-        _localValue = localValue;
-        _value = value;
-    }
-    public final Object getValue() {
-        return _value;
-    }
-    public final Object getLocalValue() {
-        return _localValue;
-    }
-    public final ConverterDecorator getConverter() {
-        return _converterDecorator;
-    }
-    public String[] getInterfaces()
-    {
-        return new String[] {ComponentFactory.INTERFACE_VALUEHOLDER};
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/AbstractVisitor.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/AbstractVisitor.java
deleted file mode 100644
index a18b04f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/AbstractVisitor.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.component;
-
-/**
- * Implemented by visitors
- * 
- * @author cbateman
- * 
- */
-public abstract class AbstractVisitor
-{
-    /**
-     * A policy to control visitation
-     */
-    protected final VisitationPolicy _policy;
-
-    /**
-     * @param policy
-     */
-    protected AbstractVisitor(final VisitationPolicy policy)
-    {
-        super();
-        _policy = policy;
-    }
-
-    /**
-     * @param object
-     */
-    public abstract void visit(Object object);
-
-    /**
-     * @return the visitation policy
-     */
-    public VisitationPolicy getPolicy()
-    {
-        return _policy;
-    }
-
-    /**
-     * A policy that allows a visitor to configure how it will visit a tree.
-     * 
-     */
-    public static final class VisitationPolicy
-    {
-        /**
-         * indicates pre-order, parent first traversal (root visited first)
-         */
-        public static final int              VISIT_PARENT_FIRST   = 0;                          // pre-order
-        // tree
-        // visit
-        /**
-         * indicates post-order, children first traveral (root visited last)
-         */
-        public static final int              VISIT_CHILDREN_FIRST = 1;                          // post-order
-        // tree
-        // visit
-        /**
-         * A default parent first policy
-         */
-        public final static VisitationPolicy ParentFirstPolicy    = new VisitationPolicy(
-                VISIT_PARENT_FIRST);
-        /**
-         * A default children first policy
-         */
-        public final static VisitationPolicy ChildrenFirstPolicy  = new VisitationPolicy(
-                VISIT_CHILDREN_FIRST);
-
-        private final int                    _ordering;
-
-        /**
-         * @param ordering
-         */
-        public VisitationPolicy(final int ordering)
-        {
-            _ordering = ordering;
-        }
-
-        /**
-         * @return the ordering
-         */
-        public final int getOrdering()
-        {
-            return _ordering;
-        }
-    }
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/ComponentFactory.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/ComponentFactory.java
deleted file mode 100644
index a3c3762..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/ComponentFactory.java
+++ /dev/null
@@ -1,399 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.component;
-
-import java.util.Map;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.bean.DataModelInfo;
-import org.eclipse.jst.jsf.common.runtime.internal.model.behavioural.IActionSource2Info;
-import org.eclipse.jst.jsf.common.runtime.internal.model.behavioural.IActionSourceInfo;
-import org.eclipse.jst.jsf.common.runtime.internal.model.behavioural.IEditableValueHolderInfo;
-import org.eclipse.jst.jsf.common.runtime.internal.model.behavioural.INamingContainerInfo;
-import org.eclipse.jst.jsf.common.runtime.internal.model.behavioural.IValueHolderInfo;
-import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ConverterDecorator;
-import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.FacetDecorator;
-import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ValidatorDecorator;
-import org.eclipse.jst.jsf.common.runtime.internal.model.event.IActionListenerInfo;
-import org.eclipse.jst.jsf.common.runtime.internal.model.event.IValueChangeListenerInfo;
-
-/**
- * Factory for creating component related objects.
- * 
- * @author cbateman
- * 
- */
-public class ComponentFactory
-{
-
-    /**
-     * The key for the standard ValueHolder adapter interface
-     */
-    public final static Class VALUE_HOLDER = IValueHolderInfo.class;
-    /**
-     * The key for the standard EditableValueHolder adapter interface
-     */
-    public final static Class EDITABLE_VALUE_HOLDER = IEditableValueHolderInfo.class;
-    /**
-     * The key for the standard ActionSource adapter interface
-     */
-    public final static Class ACTION_SOURCE = IActionSourceInfo.class;
-    /**
-     * The key for the standard ActionSource2 adapter interface
-     */
-    public final static Class ACTION_SOURCE2 = IActionSource2Info.class;
-    /**
-     * The key for the standard NamingContainer adapter interface
-     */
-    public final static Class NAMING_CONTAINER = INamingContainerInfo.class;
-
-    /**
-     * The key for the standard Converter decorator
-     */
-    public final static Class CONVERTER = ConverterDecorator.class;
-    /**
-     * The key for the standard Facet decorator
-     */
-    public final static Class FACET = FacetDecorator.class;
-    /**
-     * The key for the standard Validator decorator
-     */
-    public final static Class VALIDATOR = ValidatorDecorator.class;
-    /**
-     * The key for the standard ValueChangeListener decorator
-     */
-    public final static Class VALUE_CHANGE_LISTENER = IValueChangeListenerInfo.class;
-    /**
-     * The key for the standard ActionListener decorator
-     */
-    public final static Class ACTION_LISTENER = IActionListenerInfo.class;
-
-    /**
-     * Base class name for UIInput's
-     */
-    public final static String BASE_CLASS_UIINPUT = "javax.faces.component.UIInput"; //$NON-NLS-1$
-    /**
-     * Base class name for UIOutput's
-     */
-    public final static String BASE_CLASS_UIOUTPUT = "javax.faces.component.UIOutput"; //$NON-NLS-1$
-    /**
-     * Base class name for UICommand's
-     */
-    public final static String BASE_CLASS_UICOMMAND = "javax.faces.component.UICommand"; //$NON-NLS-1$
-    /**
-     * Base class name for UIData's
-     */
-    public final static String BASE_CLASS_UIDATA = "javax.faces.component.UIData"; //$NON-NLS-1$
-    /**
-     * Base class name for UIForm's
-     */
-    public final static String BASE_CLASS_UIFORM = "javax.faces.component.UIForm"; //$NON-NLS-1$
-
-    /**
-     * Interface name for ValueHolder's
-     */
-    public final static String INTERFACE_VALUEHOLDER = "javax.faces.component.ValueHolder"; //$NON-NLS-1$
-    /**
-     * Interface name for EditableValueHolder's
-     */
-    public final static String INTERFACE_EDITABLEVALUEHOLDER = "javax.faces.component.EditableValueHolder"; //$NON-NLS-1$
-    /**
-     * Interface name for ActionSource's
-     */
-    public final static String INTERFACE_ACTIONSOURCE = "javax.faces.component.ActionSource"; //$NON-NLS-1$
-    /**
-     * Interface name for ActionSource2's
-     */
-    public final static String INTERFACE_ACTIONSOURCE2 = "javax.faces.component.ActionSource2"; //$NON-NLS-1$
-    /**
-     * Interface name for NamingContainer's
-     */
-    public final static String INTERFACE_NAMINGCONTAINER = "javax.faces.component.NamingContainer"; //$NON-NLS-1$
-
-    /**
-     * @param id
-     * @param parent
-     * @param typeInfo
-     * @param isRendered
-     * @return a new component info
-     */
-    public static ComponentInfo createComponentInfo(final String id,
-            final ComponentInfo parent, final ComponentTypeInfo typeInfo,
-            final boolean isRendered)
-    {
-        return new ComponentInfo(id, parent, typeInfo, isRendered);
-    }
-
-    /**
-     * If the rendered attribute isn't set, defaults it.
-     * 
-     * @param attributes
-     */
-    public static void maybeDefaultRendered(final Map attributes)
-    {
-        if (!(attributes.get("rendered") instanceof Boolean)) //$NON-NLS-1$
-        {
-            attributes.put("rendered", Boolean.TRUE); //$NON-NLS-1$
-        }
-    }
-
-    /**
-     * @param parent
-     * @param componentTypeInfo
-     * @param attributes
-     * @return a new component info
-     */
-    public static ComponentInfo createComponentInfo(final ComponentInfo parent,
-            final ComponentTypeInfo componentTypeInfo, final Map attributes)
-    {
-        maybeDefaultRendered(attributes);
-        return new ComponentInfo(parent, componentTypeInfo, attributes);
-    }
-
-    /**
-     * @param id
-     * @param parent
-     * @param typeInfo
-     * @param editableValueHolder
-     * @param isRendered
-     * @return a new UIInputInfo
-     */
-    public static UIInputInfo createUIInputInfo(final String id,
-            final ComponentInfo parent, final ComponentTypeInfo typeInfo,
-            final IEditableValueHolderInfo editableValueHolder,
-            final boolean isRendered)
-    {
-        return new UIInputInfo(id, parent, typeInfo, editableValueHolder,
-                isRendered);
-    }
-
-    /**
-     * @param parent
-     * @param typeInfo
-     * @param attributes
-     * @return a new UIInputInfo
-     */
-    public static UIInputInfo createUIInputInfo(final ComponentInfo parent,
-            final ComponentTypeInfo typeInfo, final Map attributes)
-    {
-        maybeDefaultRendered(attributes);
-        return new UIInputInfo(parent, typeInfo, attributes);
-    }
-
-    /**
-     * @param id
-     * @param parent
-     * @param typeInfo
-     * @param valueHolderInfo
-     * @param isRendered
-     * @return a new UIOutputInfo
-     */
-    public static UIOutputInfo createUIOutputInfo(final String id,
-            final ComponentInfo parent, final ComponentTypeInfo typeInfo,
-            final IValueHolderInfo valueHolderInfo, final boolean isRendered)
-    {
-        return new UIOutputInfo(id, parent, typeInfo, valueHolderInfo,
-                isRendered);
-    }
-
-    /**
-     * @param parent
-     * @param typeInfo
-     * @param attributes
-     * @return a new UIOutputInfo
-     */
-    public static UIOutputInfo createUIOutputInfo(final ComponentInfo parent,
-            final ComponentTypeInfo typeInfo, final Map attributes)
-    {
-        maybeDefaultRendered(attributes);
-        return new UIOutputInfo(parent, typeInfo, attributes);
-    }
-
-    /**
-     * @param id
-     * @param parent
-     * @param typeInfo
-     * @param actionSourceInfo
-     * @param isRendered
-     * @return a new UICommandInfo
-     */
-    public static UICommandInfo createUICommandInfo(final String id,
-            final ComponentInfo parent, final ComponentTypeInfo typeInfo,
-            final IActionSourceInfo actionSourceInfo, final boolean isRendered)
-    {
-        return new UICommandInfo(id, parent, typeInfo, isRendered,
-                actionSourceInfo);
-    }
-
-    /**
-     * @param parent
-     * @param typeInfo
-     * @param attributes
-     * @return a new UICommandInfo
-     */
-    public static UICommandInfo createUICommandInfo(final ComponentInfo parent,
-            final ComponentTypeInfo typeInfo, final Map attributes)
-    {
-        maybeDefaultRendered(attributes);
-        return new UICommandInfo(parent, typeInfo, attributes);
-    }
-
-    /**
-     * @param id
-     * @param parent
-     * @param typeInfo
-     * @param isRendered
-     * @param prependId
-     * @param submitted
-     * @return a new UIFormInfo
-     */
-    public static UIFormInfo createUIFormInfo(final String id,
-            final ComponentInfo parent, final ComponentTypeInfo typeInfo,
-            final boolean isRendered, final boolean prependId,
-            final boolean submitted)
-    {
-        return new UIFormInfo(id, parent, typeInfo, isRendered, prependId,
-                submitted);
-    }
-
-    /**
-     * @param parent
-     * @param typeInfo
-     * @param attributes
-     * @return a new UIFormInfo
-     */
-    public static UIFormInfo createUIFormInfo(final ComponentInfo parent,
-            final ComponentTypeInfo typeInfo, final Map attributes)
-    {
-        maybeDefaultRendered(attributes);
-        maybeDefaultPrependId(attributes);
-        maybeDefaultSubmitted(attributes);
-        return new UIFormInfo(parent, typeInfo, attributes);
-    }
-
-    private static void maybeDefaultSubmitted(Map attributes)
-    {
-        if (!(attributes.get("submitted") instanceof Boolean)) //$NON-NLS-1$
-        {
-            attributes.put("submitted", Boolean.FALSE); //$NON-NLS-1$
-        }
-    }
-
-    private static void maybeDefaultPrependId(Map attributes)
-    {
-        if (!(attributes.get("prependId") instanceof Boolean)) //$NON-NLS-1$
-        {
-            attributes.put("prependId", Boolean.FALSE); //$NON-NLS-1$
-        }
-    }
-
-    /**
-     * @param id
-     * @param parent
-     * @param typeInfo
-     * @param isRendered
-     * @param dataModel
-     * @param first
-     * @param footer
-     * @param header
-     * @param rowCount
-     * @param rowAvailable
-     * @param rowData
-     * @param rowIndex
-     * @param rows
-     * @param value
-     * @param var
-     * @return a new UIDataInfo
-     */
-    public static UIDataInfo createUIDataInfo(final String id,
-            final ComponentInfo parent, final ComponentTypeInfo typeInfo,
-            final boolean isRendered, final DataModelInfo dataModel,
-            final int first, final ComponentInfo footer,
-            final ComponentInfo header, final int rowCount,
-            final boolean rowAvailable, final Object rowData,
-            final int rowIndex, final int rows, final Object value,
-            final String var)
-    {
-        return new UIDataInfo(id, parent, typeInfo, isRendered, dataModel,
-                first, footer, header, rowCount, rowAvailable, rowData,
-                rowIndex, rows, value, var);
-    }
-
-    /**
-     * @param parent
-     * @param typeInfo
-     * @param attributes
-     * @return the UIDataInfo
-     */
-    public static UIDataInfo createUIDataInfo(final ComponentInfo parent,
-            final ComponentTypeInfo typeInfo, final Map attributes)
-    {
-        maybeDefaultRendered(attributes);
-        maybeDefaultFirst(attributes);
-        maybeDefaultRowCount(attributes);
-        maybeDefaultRowAvailable(attributes);
-        maybeDefaultRowIndex(attributes);
-        maybeDefaultRows(attributes);
-        maybeDefaultVar(attributes);
-        return new UIDataInfo(parent, typeInfo, attributes);
-    }
-
-
-    private static final Integer ZERO = new Integer(0);
-    private static final Integer MINUS_ONE = new Integer(-1);
-
-    private static void maybeDefaultFirst(Map attributes)
-    {
-        if (!(attributes.get("first") instanceof Integer)) //$NON-NLS-1$
-        {
-            attributes.put("first", ZERO); //$NON-NLS-1$
-        }
-    }
-
-    private static void maybeDefaultRowCount(Map attributes)
-    {
-        if (!(attributes.get("rowCount") instanceof Integer)) //$NON-NLS-1$
-        {
-            attributes.put("rowCount", MINUS_ONE); //$NON-NLS-1$
-        }
-    }
-
-    private static void maybeDefaultRowAvailable(Map attributes)
-    {
-        if (! (attributes.get("rowAvailable") instanceof Boolean)) //$NON-NLS-1$
-        {
-            attributes.put("rowAvailable", Boolean.FALSE); //$NON-NLS-1$
-        }
-    }
-
-    private static void maybeDefaultRowIndex(Map attributes)
-    {
-        if (! (attributes.get("rowIndex") instanceof Integer)) //$NON-NLS-1$
-        {
-            attributes.put("rowIndex", MINUS_ONE); //$NON-NLS-1$
-        }
-    }
-
-    private static void maybeDefaultRows(Map attributes)
-    {
-        if (! (attributes.get("rows") instanceof Integer)) //$NON-NLS-1$
-        {
-            attributes.put("rows", ZERO); //$NON-NLS-1$
-        }
-    }
-
-    private static void maybeDefaultVar(Map attributes)
-    {
-        if (! (attributes.get("var") instanceof String)) //$NON-NLS-1$
-        {
-            attributes.put("var", "** default variable **"); //$NON-NLS-1$ //$NON-NLS-2$
-        }
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/ComponentInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/ComponentInfo.java
deleted file mode 100644
index 6bb4629..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/ComponentInfo.java
+++ /dev/null
@@ -1,930 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.component;
-
-import java.beans.BeanInfo;
-import java.beans.IntrospectionException;
-import java.beans.Introspector;
-import java.beans.PropertyDescriptor;
-import java.io.Serializable;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.Map.Entry;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.ViewObject;
-import org.eclipse.jst.jsf.common.runtime.internal.model.component.AbstractVisitor.VisitationPolicy;
-import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.FacetDecorator;
-
-/**
- * Models a basic UI component instance
- * 
- * TODO: should implement a visitor pattern to traverse component trees
- * 
- * @author cbateman
- * 
- */
-public class ComponentInfo extends ViewObject implements Serializable,
-        IVisitable
-{
-    /**
-     * serializable id
-     */
-    private static final long             serialVersionUID     = 2517204356825585699L;
-
-    private final static int              DEFAULT_ARRAY_SIZE   = 4;
-
-    private transient BeanPropertyManager _beanPropertyManager;
-    /**
-     * Encapsulates all of the data for the view object
-     */
-    protected final ComponentInfoData     _data;
-
-    // initialized
-    // by
-    // getBeanProperties
-
-    /**
-     * @param id
-     * @param parent
-     * @param componentTypeInfo
-     * @param isRendered
-     */
-    protected ComponentInfo(final String id, final ComponentInfo parent,
-            final ComponentTypeInfo componentTypeInfo, final boolean isRendered)
-    {
-        super(new ComponentInfoData(id, parent, componentTypeInfo, isRendered));
-        _data = (ComponentInfoData) super.getData();
-        
-        final Set propExclude = new HashSet();
-        propExclude.add("attributeNames"); //$NON-NLS-1$
-        propExclude.add("componentTypeInfo"); //$NON-NLS-1$
-        propExclude.add("valueChangeListeners"); //$NON-NLS-1$
-        propExclude.add("visitableChildren"); //$NON-NLS-1$
-
-        _beanPropertyManager = new BeanPropertyManager(this, propExclude);
-    }
-
-    /**
-     * @param data
-     */
-    protected ComponentInfo(final ComponentInfoData data)
-    {
-        super(data);
-        _data = data;
-    }
-
-    /**
-     * Construct a new component info using the attributes keyed by name in
-     * attributes to set values. The names must match the corresponding bean
-     * property names. Primitives should be wrapped in their corresponding
-     * object types. Exceptions will be thrown if there is a type mismatch on an
-     * expected type. Number will be used for all numeric primitive wrappers an
-     * the corresponding "to" will be called.
-     * 
-     * @param parent
-     * @param componentTypeInfo
-     * @param attributes
-     * @throws ClassCastException
-     *             if an attribute's value doesn't match the expected type
-     * @throws NullPointerException
-     *             if an attribute value is null for a value whose type is
-     *             expected to be primitive
-     * @throws IllegalArgumentException
-     *             if attributes does not contain a required key.
-     */
-    protected ComponentInfo(final ComponentInfo parent,
-            final ComponentTypeInfo componentTypeInfo, final Map attributes)
-    {
-        this(getStringProperty("id", attributes, false), parent, //$NON-NLS-1$
-                componentTypeInfo, getBooleanProperty("rendered", attributes, false)); //$NON-NLS-1$
-    }
-
-    /**
-     * @param key
-     * @param attributes
-     * @param mandatory
-     * @return the value in attributes at location key, forcing a
-     *         ClassCastException if it turns out not to be a String.
-     * @throws ClassCastException
-     *             if the attribute for key is not a String
-     * @throws IllegalArgumentException
-     *             if the attribute for key is null but mandatory is true.
-     */
-    protected static String getStringProperty(final String key,
-            final Map attributes, final boolean mandatory)
-    {
-        final Object value = attributes.get(key);
-
-        if (mandatory && value == null)
-        {
-            throw new IllegalArgumentException(key
-                    + " is a mandatory attribute"); //$NON-NLS-1$
-        }
-        return (String) value;
-    }
-
-    /**
-     * @param key
-     * @param attributes
-     * @param mandatory 
-     * 
-     * @return the value in attributes at location, forcing a ClassCastExceptio
-     *         if it is not a Boolean and mandatory.  returns false if no value
-     *         and not mandatory
-     * @throws IllegalArgumentException
-     *             if key is not found and value is mandatory
-     */
-    protected static boolean getBooleanProperty(final String key,
-            final Map attributes, final boolean mandatory)
-    {
-        final Boolean value = (Boolean) attributes.get(key);
-
-        if (value == null)
-        {
-            if (mandatory)
-            {
-                throw new IllegalArgumentException(key + "is mandatory"); //$NON-NLS-1$
-            }
-            return false;
-        }
-
-        return value.booleanValue();
-    }
-
-    /**
-     * @param key
-     * @param attributes
-     * @return the integer property for key. Casts the value to Number and calls
-     *         Number.intValue().  0 if no value.
-     */
-    protected static int getIntegerProperty(final String key,
-            final Map attributes)
-    {
-        final Number value = (Number) attributes.get(key);
-
-        if (value == null)
-        {
-            return 0;
-        }
-
-        return value.intValue();
-    }
-
-    /**
-     * @param key
-     * @param attributes
-     * @return the component info value from attributes
-     */
-    protected static ComponentInfo getComponentProperty(final String key,
-            final Map attributes)
-    {
-        return (ComponentInfo) attributes.get(key);
-    }
-
-    /**
-     * @return the id
-     */
-    public final String getId()
-    {
-        return _data.getId();
-    }
-
-    /**
-     * @return the component type info
-     */
-    public final ComponentTypeInfo getComponentTypeInfo()
-    {
-        return _data.getComponentTypeInfo();
-    }
-
-    /**
-     * Pre-condition: isModifiable() == true Post-condition: getChildren() will
-     * return an empty list.
-     */
-    protected final void clearChildren()
-    {
-        _data.getChildren().clear();
-    }
-
-    /**
-     * @return the children. List is unmodifiable. List contains all children
-     *         including facets.
-     */
-    public final List/* <ComponentInfo> */getChildren()
-    {
-        if (_data.isProtected())
-        {
-            return _data.getChildren();
-        }
-        return Collections.unmodifiableList(_data.getChildren());
-    }
-
-    /**
-     * Get the sub-set of {@link #getChildren()} that are facets. This is a
-     * convenience method for {@link #getDecorators(Class)}
-     * 
-     * @return all component children that are facets
-     */
-    public final List getFacets()
-    {
-        return getDecorators(ComponentFactory.FACET);
-    }
-
-    /**
-     * @param childComponent
-     */
-    public final void addChild(final ComponentInfo childComponent)
-    {
-        if (childComponent == this)
-        {
-            throw new IllegalArgumentException(
-                    "A component cannot be its own child"); //$NON-NLS-1$
-        }
-        _data.addChild(childComponent);
-        // we need to reset the child's parent to me
-        childComponent.setParent(this);
-    }
-
-    /**
-     * @param parent
-     */
-    public final void setParent(ComponentInfo parent)
-    {
-        _data.setParent(parent);
-    }
-
-    /**
-     * @param name
-     * @param facetComponent
-     */
-    public final void addFacet(final String name,
-            final ComponentInfo facetComponent)
-    {
-        addChild(facetComponent);
-        addDecorator(new FacetDecorator(name, facetComponent));
-    }
-
-    /**
-     * @param component
-     * @return if component corresponds to a facet of this component, returns
-     *         the name of that facet. Returns null if not found.
-     */
-    public final String getFacetName(final ComponentInfo component)
-    {
-        if (component == null)
-        {
-            return null;
-        }
-
-        final List facets = getDecorators(ComponentFactory.FACET);
-
-        for (final Iterator it = facets.iterator(); it.hasNext();)
-        {
-            final FacetDecorator facet = (FacetDecorator) it.next();
-            if (component == facet.getDecorates())
-            {
-                return facet.getName();
-            }
-        }
-
-        // component is not a facet
-        return null;
-    }
-
-    /**
-     * @param name
-     * @return if this has a facet called name, then returns it's single root
-     *         component.
-     */
-    public final ComponentInfo getFacet(final String name)
-    {
-        if (name == null)
-        {
-            return null;
-        }
-
-        final List facets = getDecorators(ComponentFactory.FACET);
-
-        for (final Iterator it = facets.iterator(); it.hasNext();)
-        {
-            final FacetDecorator facet = (FacetDecorator) it.next();
-            if (name.equals(facet.getName()))
-            {
-                return facet.getDecorates();
-            }
-        }
-
-        // not found
-        return null;
-    }
-
-    public String toString()
-    {
-        final String parentId = getParent() != null ? getParent().getId()
-                : "null"; //$NON-NLS-1$
-        String toString = getMostSpecificComponentName() + ": id=" //$NON-NLS-1$
-                + _data.getId() + ", parentId: " + parentId + ", family=" //$NON-NLS-1$ //$NON-NLS-2$
-                + getComponentTypeInfo().getComponentFamily() + ", render=" //$NON-NLS-1$
-                + getComponentTypeInfo().getRenderFamily() + ", rendered=" //$NON-NLS-1$
-                + isRendered();
-
-        // use bean introspection to dump child properties
-        if (this.getClass() != ComponentInfo.class)
-        {
-            toString += dumpProperties();
-        }
-
-        return toString;
-    }
-
-    private String dumpProperties()
-    {
-        String properties = ""; //$NON-NLS-1$
-        try
-        {
-            final BeanInfo beanInfo = Introspector.getBeanInfo(this.getClass(),
-                    ComponentInfo.class);
-
-            final PropertyDescriptor[] descriptors = beanInfo
-                    .getPropertyDescriptors();
-            for (int i = 0; i < descriptors.length; i++)
-            {
-                final PropertyDescriptor desc = descriptors[i];
-                final String name = desc.getName();
-                final Object valueObj = desc.getValue(name);
-                final String value = valueObj != null ? valueObj.toString()
-                        : "null"; //$NON-NLS-1$
-                properties += ", " + name + "=" + value; //$NON-NLS-1$ //$NON-NLS-2$
-            }
-        }
-        catch (final IntrospectionException e)
-        {
-            return "Error introspecting bean: " + e.getLocalizedMessage(); //$NON-NLS-1$
-        }
-
-        return properties;
-    }
-
-    /**
-     * @return used for toString. Clients should not use.
-     */
-    protected String getMostSpecificComponentName()
-    {
-        return "UIComponent"; //$NON-NLS-1$
-    }
-
-    /**
-     * @return the parent of this component or null.
-     */
-    public final ComponentInfo getParent()
-    {
-        return _data.getParent();
-    }
-
-    /**
-     * @return the rendered flag
-     */
-    public final boolean isRendered()
-    {
-        return _data.isRendered();
-    }
-
-    public synchronized void addAdapter(final Class adapterType,
-            final Object adapter)
-    {
-        super.addAdapter(adapterType, adapter);
-
-        // force an update on the next call to getBeanProperties
-        _beanPropertyManager.reset();
-    }
-
-    public synchronized Object removeAdapter(final Class adapterType)
-    {
-        final Object removed = super.removeAdapter(adapterType);
-
-        _beanPropertyManager.reset();
-
-        return removed;
-    }
-
-    /**
-     * @return the set of all bean property names for this component. The set is
-     *         unmodifiable and will throw exceptions if modification is
-     *         attempted.
-     */
-    protected final Map/* <String, ComponentBeanProperty> */getBeanProperties()
-    {
-        return Collections.unmodifiableMap(_beanPropertyManager
-                .getBeanProperties());
-    }
-
-    /**
-     * @author cbateman
-     * 
-     */
-    public static class ComponentInfoData extends ViewObjectData
-    {
-        /**
-         * 
-         */
-        private static final long         serialVersionUID                = 5052732412917986062L;
-        /**
-         * the component id
-         */
-        private final String              _id;
-        /**
-         * the component's parent or null if none
-         */
-        private ComponentInfo             _parent;
-
-        /**
-         * the type info for this component
-         */
-        protected final ComponentTypeInfo _componentTypeInfo;
-        /**
-         * the rendered flage
-         */
-        protected final boolean           _isRendered;
-
-        private List                     /* <ComponentInfo> */_children = new ArrayList(
-                                                                                  DEFAULT_ARRAY_SIZE);
-
-        /**
-         * @param id
-         * @param parent
-         * @param componentTypeInfo
-         * @param isRendered
-         */
-        public ComponentInfoData(final String id, ComponentInfo parent,
-                ComponentTypeInfo componentTypeInfo, boolean isRendered)
-        {
-            super(false);
-            _id = id;
-            _parent = parent;
-            _componentTypeInfo = componentTypeInfo;
-            _isRendered = isRendered;
-        }
-
-        /**
-         * @param childComponent
-         */
-        protected void addChild(ComponentInfo childComponent)
-        {
-            enforceProtection();
-
-            getChildren().add(childComponent);
-        }
-
-        /**
-         * @return the modifiable list of children
-         */
-        protected final List/* <ComponentInfo> */getChildren()
-        {
-            return _children;
-        }
-
-        protected void doBeforeProtecting()
-        {
-            super.doBeforeProtecting();
-            // compact the children array list
-            if (_children.size() > 0)
-            {
-                _children = Collections.unmodifiableList(_children);
-            }
-            else
-            {
-                _children = Collections.EMPTY_LIST;
-            }
-        }
-
-        /**
-         * @return the isRendered flag
-         */
-        protected final boolean isRendered()
-        {
-            return _isRendered;
-        }
-
-        /**
-         * @return the component type info flag
-         */
-        protected final ComponentTypeInfo getComponentTypeInfo()
-        {
-            return _componentTypeInfo;
-        }
-
-        /**
-         * @return the parent or null if no parent
-         */
-        protected final ComponentInfo getParent()
-        {
-            return _parent;
-        }
-
-        /**
-         * @param parent
-         */
-        protected final void setParent(ComponentInfo parent)
-        {
-            enforceProtection();
-            _parent = parent;
-        }
-
-        /**
-         * @return the component id
-         */
-        protected final String getId()
-        {
-            return _id;
-        }
-    }
-
-    /**
-     * This is similar to the runtime getAttributes().get(name) call. The reason
-     * we don't implement a Map of all attribute values is that the implicit
-     * property structure can change at any time due to add/removeAdapter. To
-     * get all attributes known for a component, instead use:
-     * 
-     * The synchronized block is advised to protect against concurrent
-     * modification exceptions on the keySet iterator.
-     * 
-     * @param name
-     * 
-     * @return the value of the attribute or null if none.
-     * 
-     */
-    public synchronized ComponentBeanProperty getAttribute(final String name)
-    {
-        return (ComponentBeanProperty) getBeanProperties().get(name);
-    }
-
-    /**
-     * @return the set of valid attribute names. The Set is not modifiable.
-     */
-    public synchronized Set/* <String> */getAttributeNames()
-    {
-        return getBeanProperties().keySet();
-    }
-
-    /**
-     * Stores a bean property descriptor along information about which
-     * implementation class declares it and what key to pass to getAdapter() in
-     * order to get it.
-     * 
-     */
-    public final static class ComponentBeanProperty
-    {
-        private final PropertyDescriptor _propertyDescriptor;
-        private final Object             _declaringImplementation;
-        private final Class              _adapterKeyClass;
-
-        // only instantiable locally
-        private ComponentBeanProperty(Class adapterKeyClass,
-                Object declaringImplementationClass,
-                PropertyDescriptor propertyDescriptor)
-        {
-            super();
-            _adapterKeyClass = adapterKeyClass;
-            _declaringImplementation = declaringImplementationClass;
-            _propertyDescriptor = propertyDescriptor;
-        }
-
-        /**
-         * @return the value of property
-         */
-        public final Object getValue()
-        {
-            final Method method = _propertyDescriptor.getReadMethod();
-            if (method != null)
-            {
-                try
-                {
-                    method.setAccessible(true);
-                    return method.invoke(_declaringImplementation,
-                            new Object[0]);
-                }
-                catch (IllegalArgumentException e)
-                {
-                    e.printStackTrace();
-                }
-                catch (IllegalAccessException e)
-                {
-                    e.printStackTrace();
-                }
-                catch (InvocationTargetException e)
-                {
-                    e.printStackTrace();
-                }
-            }
-            // if any step fails, return null
-            return null;
-        }
-
-        /**
-         * @return the property descriptor
-         */
-        public final PropertyDescriptor getPropertyDescriptor()
-        {
-            return _propertyDescriptor;
-        }
-
-        /**
-         * @return the implemenation
-         */
-        public final Object getDeclaringImplementationClass()
-        {
-            return _declaringImplementation;
-        }
-
-        /**
-         * @return the adapter class for the interface that the declaring
-         *         implementation is providing the impl for
-         */
-        public final Class getAdapterKeyClass()
-        {
-            return _adapterKeyClass;
-        }
-    }
-
-    /**
-     * Manages bean property information for a component
-     * 
-     * @author cbateman
-     * 
-     */
-    protected final static class BeanPropertyManager
-    {
-        /**
-         * a map of the bean property names exposed by this component including
-         * all those added by addAdapter().
-         * 
-         * this is synthetic based the class definition and installed adapters
-         * so as long that info is available, no need to serialize.
-         */
-        protected transient Map              /*
-                                                 * <String,
-                                                 * ComponentBeanProperty>
-                                                 */_beanProperties; // lazily
-        private final transient ComponentInfo _component;
-        private final transient Set _excludeNames;
-
-        /**
-         * @param component
-         * @param excludeNames 
-         */
-        protected BeanPropertyManager(final ComponentInfo component,
-                final Set excludeNames)
-        {
-            _component = component;
-            _excludeNames = excludeNames;
-        }
-
-        /**
-         * Will throw exception of the calling thread already holds the "this"
-         * monitor lock. This is to ensure that caller always acquires locks in
-         * appropriate order to prevent deadlock.
-         * 
-         * @return the internal set of bean properties. This Set may be modified
-         *         internally.
-         */
-        public Map getBeanProperties()
-        {
-            if (Thread.holdsLock(this))
-            {
-                throw new IllegalStateException(
-                        "Must not already own this lock"); //$NON-NLS-1$
-            }
-
-            // must always acquire component lock first to prevent deadlock
-            synchronized (_component)
-            {
-                synchronized (this)
-                {
-                    if (_beanProperties == null)
-                    {
-                        _beanProperties = calculateAllBeanPropNames(ViewObject.class);
-                    }
-
-                    return _beanProperties;
-                }
-            }
-        }
-
-        /**
-         * Will throw exception if the calling thread already holds the "this"
-         * monitor lock. This is to ensure that caller always acquires locks in
-         * appropriate order to prevent deadlock.
-         * 
-         * Clears the internal map and sets to null. This will force it to be
-         * completely new built on the next call to getBeanProperties
-         */
-        public void reset()
-        {
-            if (Thread.holdsLock(this))
-            {
-                throw new IllegalStateException(
-                        "Must not already own this lock"); //$NON-NLS-1$
-            }
-
-            // must always acquire component lock first to prevent deadlock
-            synchronized (_component)
-            {
-                synchronized (this)
-                {
-                    if (_beanProperties != null)
-                    {
-                        _beanProperties.clear();
-                        _beanProperties = null;
-                    }
-                }
-            }
-        }
-
-        /**
-         * @param stopClass
-         * @return a synchronized map of all bean property names on this class
-         *         up to stopClass, as well as all adapter property names (as
-         *         though this really implemented them).
-         */
-        private Map calculateAllBeanPropNames(final Class stopClass)
-        {
-            // use a set to prevents the duplicates
-            final Map allProperties = new HashMap();
-
-            {
-                final Class myClass = _component.getClass();
-                final List myProperties = getOrCreateBeanProperties(myClass,
-                        stopClass);
-
-                addToMap(myProperties, _component, myClass, allProperties, _excludeNames);
-            }
-
-            {
-                for (final Iterator it = _component.getAdapterMap().entrySet()
-                        .iterator(); it.hasNext();)
-                {
-                    Map.Entry entry = (Entry) it.next();
-
-                    final Class adapterClass = (Class) entry.getKey();
-                    final Object declaringClass = entry.getValue();
-                    // get all props, excluding the ones on Object.
-                    final List props = getOrCreateBeanProperties(adapterClass,
-                            null);
-                    addToMap(props, declaringClass, adapterClass, allProperties,
-                            _excludeNames);
-                }
-            }
-
-            return Collections.synchronizedMap(allProperties);
-        }
-
-        private static void addToMap(
-                final List/* <ComponentBeanProperty> */addThese,
-                final Object declaringObject, final Class declaringAdapter,
-                final Map toMe,
-                Set excludeNames)
-        {
-            for (final Iterator it = addThese.iterator(); it.hasNext();)
-            {
-                final PropertyDescriptor desc = (PropertyDescriptor) it.next();
-
-                if (!toMe.containsKey(desc.getName())
-                    && !excludeNames.contains(desc.getName()))
-                {
-                    toMe.put(desc.getName(), new ComponentBeanProperty(
-                            declaringAdapter, declaringObject, desc));
-                }
-            }
-        }
-
-        /**
-         * lazily loaded with the local properties (those not defined using
-         * adapters)
-         * 
-         * MUST INITIALIZE early so can synchronize on it
-         */
-        private transient static Map /* <Class, List<PropertyDescriptor> */PROPERTY_MAP = new HashMap();
-
-        /**
-         * @param startClass
-         * @param stopClass
-         * @return a unmodifiable list of properties starting from startClass.
-         *         stopClass is only used if an entry doesn't already exist in
-         *         PROPERTY_MAP for startClass. The method is synchronized on
-         *         the PROPERTY_MAP it updates.
-         */
-        protected static List/* <PropertyDescriptor */getOrCreateBeanProperties(
-                final Class startClass, final Class stopClass)
-        {
-            synchronized (PROPERTY_MAP)
-            {
-                List localBeanProps = (List) PROPERTY_MAP.get(startClass);
-
-                if (localBeanProps == null)
-                {
-                    localBeanProps = calculateBeanProperties(startClass,
-                            stopClass);
-                    PROPERTY_MAP.put(startClass, Collections
-                            .unmodifiableList(localBeanProps));
-                }
-
-                return localBeanProps;
-            }
-        }
-
-        /**
-         * @param startClass
-         * @param stopClass
-         * @return a List<String> containing all of the bean names between
-         *         startClass and stopClass. Start class must be a descendant
-         *         (sub-class, sub-sub-class etc.) of stopClass. The properties
-         *         on stopClass are excluded from analysis.
-         */
-        private static List/* <PropertyDescriptor> */calculateBeanProperties(
-                final Class startClass, final Class stopClass)
-        {
-            BeanInfo beanInfo;
-            List names = new ArrayList();
-
-            try
-            {
-                beanInfo = Introspector.getBeanInfo(startClass, stopClass);
-                final PropertyDescriptor[] descriptors = beanInfo
-                        .getPropertyDescriptors();
-
-                if (descriptors != null)
-                {
-                    names = Arrays.asList(descriptors);
-                }
-            }
-            catch (final IntrospectionException e)
-            {
-                e.printStackTrace();
-            }
-            return names;
-        }
-
-    }
-
-    /**
-     * Visits this node and it's entire tree and makes all nodes protected.
-     */
-    public final void setSubtreeProtected()
-    {
-        // lock children first
-        final ComponentTreeVisitor protectionVisitor = new ComponentTreeVisitor(VisitationPolicy.ChildrenFirstPolicy)
-        {
-            public void visit(ComponentInfo component)
-            {
-                component.setProtected();
-            }
-        };
-        
-        accept(protectionVisitor);
-    }
-
-    public void accept(AbstractVisitor visitor)
-    {
-        // check policy ordering
-        if (visitor.getPolicy().getOrdering() == VisitationPolicy.VISIT_PARENT_FIRST)
-        {
-            visitor.visit(this);
-            visitChildren(visitor);
-        }
-        else
-        {
-            visitChildren(visitor);
-            visitor.visit(this);
-        }
-    }
-
-    private void visitChildren(AbstractVisitor visitor)
-    {
-        for (final Iterator it = getVisitableChildren(); it.hasNext();)
-        {
-            visitor.visit(it.next());
-        }
-    }
-
-    public Iterator getVisitableChildren()
-    {
-        return getChildren().iterator();
-    }
-}
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/ComponentTreeVisitor.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/ComponentTreeVisitor.java
deleted file mode 100644
index 4bedc7c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/ComponentTreeVisitor.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.component;
-
-/**
- * An abstract class sub-classed by objects that wish to apply a Visitor pattern
- * type visitation to a component tree.
- * 
- * @author cbateman
- * 
- */
-public abstract class ComponentTreeVisitor extends AbstractVisitor
-{
-    /**
-     * @param policy
-     */
-    public ComponentTreeVisitor(final VisitationPolicy policy)
-    {
-        super(policy);
-    }
-
-    /**
-     * @param component
-     */
-    public abstract void visit(final ComponentInfo component);
-
-    public final void visit(final Object object)
-    {
-        visit((ComponentInfo) object);
-    }
-}
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/ComponentTypeInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/ComponentTypeInfo.java
deleted file mode 100644
index 74c7c9b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/ComponentTypeInfo.java
+++ /dev/null
@@ -1,106 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.component;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.types.ClassTypeInfo;
-
-/**
- * Type information about a UIComponent
- * 
- * @author cbateman
- * 
- */
-public class ComponentTypeInfo extends ClassTypeInfo
-{
-    /**
-     * serializable uid
-     */
-    private static final long serialVersionUID = -311156682935177206L;
-    /**
-     * the ComponentType (see JSF spec for definition)
-     */
-    protected final String _componentType; // may be null, since may not be
-    // known at runtime
-    /**
-     * the component family (see JSF spec)
-     */
-    protected final String _componentFamily;
-    /**
-     * the render family (see JSF spec)
-     */
-    protected final String _renderFamily;
-    
-    /**
-     * @param componentType
-     * @param componentClass
-     * @param componentFamily
-     * @param renderFamily
-     */
-    public ComponentTypeInfo(final String componentType,
-            final String componentClass, final String componentFamily,
-            final String renderFamily)
-    {
-        super(componentClass, new String[0], new String[0]);
-        _componentType = componentType;
-        _componentFamily = componentFamily;
-        _renderFamily = renderFamily;
-    }
-
-    /**
-     * @param componentType
-     * @param superClasses
-     * @param interfaces
-     * @param componentClass
-     * @param componentFamily
-     * @param renderFamily
-     */
-    public ComponentTypeInfo(final String componentType,
-            final String componentClass, 
-            final String[] superClasses, final String[] interfaces,
-            final String componentFamily,
-            final String renderFamily)
-    {
-        super(componentClass, superClasses, interfaces);
-        _componentType = componentType;
-        _componentFamily = componentFamily;
-        _renderFamily = renderFamily;
-    }
-
-    /**
-     * @return the component type or null if unknown (may not be at runtime)
-     */
-    public final String getComponentType()
-    {
-        return _componentType;
-    }
-
-    /**
-     * @return the component family
-     */
-    public final String getComponentFamily()
-    {
-        return _componentFamily;
-    }
-
-    /**
-     * @return the render family
-     */
-    public final String getRenderFamily()
-    {
-        return _renderFamily;
-    }
-
-    public String toString()
-    {
-        return "Component Type Info: type = " + _componentType + " family=" + _componentFamily //$NON-NLS-1$ //$NON-NLS-2$
-                + " renderer=" + _renderFamily + ", "+super.toString(); //$NON-NLS-1$ //$NON-NLS-2$
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/IVisitable.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/IVisitable.java
deleted file mode 100644
index 6ddd83b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/IVisitable.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.component;
-
-import java.util.Iterator;
-
-/**
- * Implemented by a class that can accept visitors
- *
- */
-interface IVisitable
-{
-    /**
-     * Called on a visitable to accept a visitor
-     * 
-     * @param visitor
-     */
-    void accept(AbstractVisitor visitor);
-    
-    /**
-     * @return an iterator that returns IVisitable children.
-     */
-    Iterator getVisitableChildren();
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/UICommandInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/UICommandInfo.java
deleted file mode 100644
index 9ff50f4..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/UICommandInfo.java
+++ /dev/null
@@ -1,117 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.component;
-
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.behavioural.IActionSource2Info;
-import org.eclipse.jst.jsf.common.runtime.internal.model.behavioural.IActionSourceInfo;
-import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ActionListenerDecorator;
-
-/**
- * An design time analog of the standard UICommand.
- * @author cbateman
- *
- */
-public class UICommandInfo extends ComponentInfo implements IActionSource2Info {
-    private final String _actionExpression;
-    private final String _actionListener;
-    private final boolean _isImmediate;
-
-    /**
-     * serialization id
-     */
-    private static final long serialVersionUID = -9025172832535840949L;
-
-    /**
-     * @param id
-     * @param parent
-     * @param componentTypeInfo
-     * @param isRendered
-     * @param actionSourceInfo
-     */
-    protected UICommandInfo(final String id, final ComponentInfo parent,
-            final ComponentTypeInfo componentTypeInfo,
-            final boolean isRendered, final IActionSourceInfo actionSourceInfo) {
-        super(id, parent, componentTypeInfo, isRendered);
-
-        if (actionSourceInfo == null) {
-            _actionExpression = null;
-            _actionListener = null;
-            _isImmediate = false;
-        } else {
-            // TODO: having action and actionExpression will come back to
-            // to bite us.
-            _actionExpression = actionSourceInfo.getAction();
-            _actionListener = actionSourceInfo.getActionListener();
-            _isImmediate = actionSourceInfo.isImmediate();
-
-            for (final Iterator it = actionSourceInfo.getActionListeners()
-                    .iterator(); it.hasNext();) {
-                final ActionListenerDecorator actionListener = 
-                    (ActionListenerDecorator) it.next();
-                addActionListener(actionListener);
-            }
-        }
-    }
-
-    /**
-     * @param parent
-     * @param componentTypeInfo
-     * @param attributes
-     */
-    protected UICommandInfo(final ComponentInfo parent, final ComponentTypeInfo componentTypeInfo,
-            Map attributes)
-    {
-        this(getStringProperty("id", attributes, true), //$NON-NLS-1$
-                parent, componentTypeInfo,
-                getBooleanProperty("rendered", attributes, false), //$NON-NLS-1$
-                getActionSourceInfo("$actionSourceInfo", attributes) //$NON-NLS-1$
-                );
-    }
-    
-    private static IActionSourceInfo getActionSourceInfo(String key,
-            Map attributes)
-    {
-        return (IActionSourceInfo) attributes.get(key);
-    }
-
-    public String getActionExpression() {
-        return _actionExpression;
-    }
-
-    public final void addActionListener(final ActionListenerDecorator actionListener) {
-        addDecorator(actionListener, ComponentFactory.ACTION_LISTENER);
-    }
-
-    public final String getAction() {
-        return _actionExpression;
-    }
-
-    public final String getActionListener() {
-        return _actionListener;
-    }
-
-    public final List getActionListeners() {
-        return getDecorators(ComponentFactory.ACTION_LISTENER);
-    }
-
-    public final boolean isImmediate() {
-        return _isImmediate;
-    }
-
-    protected String getMostSpecificComponentName()
-    {
-        return "UICommand"; //$NON-NLS-1$
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/UIDataInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/UIDataInfo.java
deleted file mode 100644
index 56981af..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/UIDataInfo.java
+++ /dev/null
@@ -1,219 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.component;
-
-import java.util.Map;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.bean.DataModelInfo;
-import org.eclipse.jst.jsf.common.runtime.internal.model.bean.SerializableObject;
-import org.eclipse.jst.jsf.common.runtime.internal.model.behavioural.INamingContainerInfo;
-
-/**
- * Design time analog to UIData.
- * 
- * @author cbateman
- * 
- */
-public class UIDataInfo extends ComponentInfo implements INamingContainerInfo
-{
-    /**
-     * the standard name for the footer facet
-     */
-    public final static String FACET_NAME_FOOTER = "footer"; //$NON-NLS-1$
-    /**
-     * the standard name for the header facet.
-     */
-    public final static String FACET_NAME_HEADER = "header"; //$NON-NLS-1$
-    /**
-     * serialization id
-     */
-    private static final long serialVersionUID = 3473288390914978784L;
-
-    private final DataModelInfo _dataModel;
-    private final int _first;
-    private final int _rowCount;
-    private final boolean _rowAvailable;
-    private final SerializableObject _rowData;
-    private final int _rowIndex;
-    private final int _rows;
-    private final SerializableObject _value;
-    private final String _var;
-
-    /**
-     * @param id
-     * @param parent
-     * @param componentTypeInfo
-     * @param isRendered
-     * @param dataModel
-     * @param first
-     * @param footer
-     * @param header
-     * @param rowCount
-     * @param rowAvailable
-     * @param rowData
-     * @param rowIndex
-     * @param rows
-     * @param value
-     * @param var
-     */
-    public UIDataInfo(final String id, final ComponentInfo parent,
-            final ComponentTypeInfo componentTypeInfo,
-            final boolean isRendered, final DataModelInfo dataModel,
-            final int first, final ComponentInfo footer,
-            final ComponentInfo header, final int rowCount,
-            final boolean rowAvailable, final Object rowData,
-            final int rowIndex, final int rows, final Object value,
-            final String var)
-    {
-        super(id, parent, componentTypeInfo, isRendered);
-        _dataModel = dataModel;
-        _first = first;
-        _rowCount = rowCount;
-        _rowAvailable = rowAvailable;
-        _rowData = new SerializableObject(rowData);
-        _rowIndex = rowIndex;
-        _rows = rows;
-        _value = new SerializableObject(value);
-        _var = var;
-
-        if (footer != null)
-        {
-            addFacet(FACET_NAME_FOOTER, footer);
-        }
-
-        if (header != null)
-        {
-            addFacet(FACET_NAME_HEADER, header);
-        }
-    }
-
-    /**
-     * @param parent
-     * @param componentTypeInfo
-     * @param attributes
-     */
-    public UIDataInfo(final ComponentInfo parent,
-            final ComponentTypeInfo componentTypeInfo, Map attributes)
-    {
-        this(getStringProperty("id", attributes, true), parent, //$NON-NLS-1$
-                componentTypeInfo, 
-                getBooleanProperty("rendered", attributes, false), //$NON-NLS-1$
-                getDataModelInfo("$dataModel", attributes),  //$NON-NLS-1$
-                getIntegerProperty("first", attributes),  //$NON-NLS-1$
-                getComponentProperty("footer", attributes), //$NON-NLS-1$
-                getComponentProperty("header", attributes),  //$NON-NLS-1$
-                getIntegerProperty("rowCount", attributes),  //$NON-NLS-1$
-                getBooleanProperty("rowAvailable", attributes, false),  //$NON-NLS-1$
-                attributes.get("rowData"), //$NON-NLS-1$
-                getIntegerProperty("rowIndex", attributes),  //$NON-NLS-1$
-                getIntegerProperty("rows", attributes),  //$NON-NLS-1$
-                attributes.get("value"), //$NON-NLS-1$
-                getStringProperty("var", attributes, false)); //$NON-NLS-1$
-    }
-
-    private static DataModelInfo getDataModelInfo(String key, Map attributes)
-    {
-        return (DataModelInfo) attributes.get(key);
-    }
-
-    /**
-     * @return the data model
-     */
-    public final DataModelInfo getDataModel()
-    {
-        return _dataModel;
-    }
-
-    /**
-     * @return the first row
-     */
-    public final int getFirst()
-    {
-        return _first;
-    }
-
-    /**
-     * @return the row count
-     */
-    public final int getRowCount()
-    {
-        return _rowCount;
-    }
-
-    /**
-     * @return true if the row is available
-     */
-    public final boolean isRowAvailable()
-    {
-        return _rowAvailable;
-    }
-
-    /**
-     * @return the row data (may be null if not serialiable)
-     */
-    public final Object getRowData()
-    {
-        return _rowData.getMaybeSerializable();
-    }
-
-    /**
-     * @return the row index
-     */
-    public final int getRowIndex()
-    {
-        return _rowIndex;
-    }
-
-    /**
-     * @return the rows
-     */
-    public final int getRows()
-    {
-        return _rows;
-    }
-
-    /**
-     * @return the value of the model (may be null if not serialiable)
-     */
-    public final Object getValue()
-    {
-        return _value.getMaybeSerializable();
-    }
-
-    /**
-     * @return the name used to define the EL row variable
-     */
-    public final String getVar()
-    {
-        return _var;
-    }
-
-    /**
-     * @return the header facet or null.
-     */
-    public final ComponentInfo getHeader()
-    {
-        return getFacet(FACET_NAME_HEADER);
-    }
-
-    /**
-     * @return the footer facet or null.
-     */
-    public final ComponentInfo getFooter()
-    {
-        return getFacet(FACET_NAME_FOOTER);
-    }
-
-    protected String getMostSpecificComponentName()
-    {
-        return "UIData"; //$NON-NLS-1$
-    }
-}
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/UIFormInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/UIFormInfo.java
deleted file mode 100644
index 2b82330..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/UIFormInfo.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.component;
-
-import java.util.Map;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.behavioural.INamingContainerInfo;
-
-/**
- * A design-time analog for the UIForm.
- * 
- * @author cbateman
- */
-public class UIFormInfo extends ComponentInfo implements INamingContainerInfo 
-{
-    /**
-     * serializable id
-     */
-    private static final long serialVersionUID = 6961034911873576644L;
-
-    private final boolean _prependId;
-    private final boolean _submitted;
-    
-    /**
-     * @param id
-     * @param parent
-     * @param componentTypeInfo
-     * @param isRendered
-     * @param prependId
-     * @param submitted
-     */
-    protected UIFormInfo(final String id, final ComponentInfo parent,
-            final ComponentTypeInfo componentTypeInfo, final boolean isRendered
-            , final boolean prependId, final boolean submitted) {
-        super(id, parent, componentTypeInfo, isRendered);
-        _prependId = prependId;
-        _submitted = submitted;
-    }
-    
-    /**
-     * @param parent
-     * @param componentTypeInfo
-     * @param attributes
-     */
-    protected UIFormInfo(final ComponentInfo parent, ComponentTypeInfo componentTypeInfo,
-            Map attributes)
-    {
-        this(getStringProperty("id", attributes, true), //$NON-NLS-1$
-                parent,
-                componentTypeInfo,
-                getBooleanProperty("rendered", attributes, false), //$NON-NLS-1$
-                getBooleanProperty("prependId", attributes, false), //$NON-NLS-1$
-                getBooleanProperty("submitted", attributes, false)); //$NON-NLS-1$
-    }
-    
-    /**
-     * JSF 1.2 only
-     * 
-     * @return true if the form allows its id to be prepended to its 
-     * descendent's ids.
-     */
-    public final boolean isPrependId()
-    {
-        return _prependId;
-    }
-
-    /**
-     * @return true if the form is submitted.
-     */
-    public final boolean isSubmitted() {
-        return _submitted;
-    }
-
-    protected String getMostSpecificComponentName()
-    {
-        return "UIForm"; //$NON-NLS-1$
-    } 
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/UIInputInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/UIInputInfo.java
deleted file mode 100644
index 14a6131..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/UIInputInfo.java
+++ /dev/null
@@ -1,182 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.component;
-
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.behavioural.IEditableValueHolderInfo;
-import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ValidatorDecorator;
-import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ValueChangeListenerDecorator;
-
-/**
- * A design-time analog of the standard UIInput.
- * 
- * @author cbateman
- * 
- */
-public class UIInputInfo extends UIOutputInfo implements
-        IEditableValueHolderInfo
-{
-    /**
-     * serializable uid
-     */
-    private static final long serialVersionUID = -6055473902554910848L;
-    private final boolean _isValid;
-    private final boolean _isImmediate;
-    private final boolean _isRequired;
-    private final Object _submittedValue;
-    private final String _validator;
-    private final String _valueChangeListener;
-    private final boolean _localSetValue;
-
-    /**
-     * @param id
-     * @param parent
-     * @param typeInfo
-     * @param editableValueHolderInfo
-     * @param isRendered
-     */
-    protected UIInputInfo(final String id, final ComponentInfo parent,
-            final ComponentTypeInfo typeInfo,
-            final IEditableValueHolderInfo editableValueHolderInfo,
-            final boolean isRendered)
-    {
-        super(id, parent, typeInfo, editableValueHolderInfo, isRendered);
-
-        if (editableValueHolderInfo == null)
-        {
-            _isValid = true;
-            _isImmediate = false;
-            _isRequired = false;
-            _localSetValue = false;
-            _submittedValue = null;
-            _validator = null;
-            _valueChangeListener = null;
-        }
-        else
-        {
-            _isValid = editableValueHolderInfo.isValid();
-            _isImmediate = editableValueHolderInfo.isImmediate();
-            _isRequired = editableValueHolderInfo.isRequired();
-            _localSetValue = editableValueHolderInfo.isLocalSetValue();
-            _submittedValue = editableValueHolderInfo.getSubmittedValue();
-            _validator = editableValueHolderInfo.getValidator();
-            _valueChangeListener = editableValueHolderInfo
-                    .getValueChangeListener();
-
-            for (final Iterator it = editableValueHolderInfo.getValidators()
-                    .iterator(); it.hasNext();)
-            {
-                final ValidatorDecorator validator = (ValidatorDecorator) it
-                        .next();
-                addValidator(validator);
-            }
-
-            for (final Iterator it = editableValueHolderInfo
-                    .getValueChangeListeners().iterator(); it.hasNext();)
-            {
-                final ValueChangeListenerDecorator valueChangeListener = (ValueChangeListenerDecorator) it
-                        .next();
-                addValueChangeListener(valueChangeListener);
-            }
-        }
-    }
-
-    /**
-     * @param parent
-     * @param typeInfo
-     * @param attributes
-     */
-    protected UIInputInfo(final ComponentInfo parent,
-            final ComponentTypeInfo typeInfo, Map attributes)
-    {
-        this(getStringProperty("id", attributes, true), parent, typeInfo, //$NON-NLS-1$
-                getEditableValueHolderInfo("$editableValueHolderInfo", //$NON-NLS-1$
-                        attributes), getBooleanProperty("rendered", attributes, false)); //$NON-NLS-1$
-    }
-
-    private static IEditableValueHolderInfo getEditableValueHolderInfo(
-            String key, Map attributes)
-    {
-        return (IEditableValueHolderInfo) attributes.get(key);
-    }
-
-    // public String toString() {
-    // final String toString = super.toString();
-    // return toString + ", isValid=" + _isValid + ", isImmediate="
-    // + _isImmediate + ", isRequired=" + _isRequired;
-    // }
-
-    // @Override
-    protected String getMostSpecificComponentName()
-    {
-        return "UIInput"; //$NON-NLS-1$
-    }
-
-    public final boolean isValid()
-    {
-        return _isValid;
-    }
-
-    public final boolean isImmediate()
-    {
-        return _isImmediate;
-    }
-
-    public final boolean isRequired()
-    {
-        return _isRequired;
-    }
-
-    public final Object getSubmittedValue()
-    {
-        return _submittedValue;
-    }
-
-    public final String getValidator()
-    {
-        return _validator;
-    }
-
-    public final String getValueChangeListener()
-    {
-        return _valueChangeListener;
-    }
-
-    public final boolean isLocalSetValue()
-    {
-        return _localSetValue;
-    }
-
-    public final void addValidator(final ValidatorDecorator validator)
-    {
-        addDecorator(validator, ComponentFactory.VALIDATOR);
-    }
-
-    public final void addValueChangeListener(
-            final ValueChangeListenerDecorator valueChangeListenerInfo)
-    {
-        addDecorator(valueChangeListenerInfo,
-                ComponentFactory.VALUE_CHANGE_LISTENER);
-    }
-
-    public final List getValidators()
-    {
-        return getDecorators(ComponentFactory.VALIDATOR);
-    }
-
-    public final List getValueChangeListeners()
-    {
-        return getDecorators(ComponentFactory.VALUE_CHANGE_LISTENER);
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/UIOutputInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/UIOutputInfo.java
deleted file mode 100644
index 990028a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/component/UIOutputInfo.java
+++ /dev/null
@@ -1,132 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.component;
-
-import java.util.List;
-import java.util.Map;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.behavioural.IValueHolderInfo;
-import org.eclipse.jst.jsf.common.runtime.internal.model.behavioural.ValueHolderInfo;
-import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ConverterDecorator;
-
-/**
- * A design-time analog for the UIOutput
- * 
- * @author cbateman
- *
- */
-public class UIOutputInfo extends ComponentInfo implements IValueHolderInfo {
-    /**
-     * serializable uid
-     */
-    private static final long serialVersionUID = 9096297578991706150L;
-
-    /**
-     * the value
-     */
-    protected final Object _value;
-    /**
-     * the value before any EL evaluation
-     */
-    protected final Object _localValue;
-
-    /**
-     * @param id
-     * @param parent
-     * @param typeInfo
-     * @param valueHolderInfo
-     * @param isRendered
-     */
-    protected UIOutputInfo(final String id, final ComponentInfo parent,
-            final ComponentTypeInfo typeInfo,
-            final IValueHolderInfo valueHolderInfo, final boolean isRendered) {
-        super(id, parent, typeInfo, isRendered);
-
-        if (valueHolderInfo == null) {
-            _value = null;
-            _localValue = null;
-        } else {
-            _value = valueHolderInfo.getValue();
-            _localValue = valueHolderInfo.getLocalValue();
-
-            final ConverterDecorator converter = valueHolderInfo.getConverter();
-            if (converter != null) {
-                addDecorator(converter, ComponentFactory.CONVERTER);
-            }
-        }
-    }
-
-    /**
-     * @param parent
-     * @param typeInfo
-     * @param attributes
-     */
-    protected UIOutputInfo(final ComponentInfo parent, final ComponentTypeInfo typeInfo,
-            final Map attributes)
-    {
-        this(getStringProperty("id", attributes, true), //$NON-NLS-1$
-                parent,
-                typeInfo,
-                getValueHolderInfo("$valueHolderInfo", attributes), //$NON-NLS-1$
-                getBooleanProperty("rendered", attributes, false)); //$NON-NLS-1$
-    }
-    
-    /**
-     * @param key
-     * @param attributes
-     * @return the non-standard value holder info that encapsulates the
-     * ValueHolder properties.  This is never mandatory.
-     */
-    protected static IValueHolderInfo getValueHolderInfo(String key, Map attributes)
-    {
-        IValueHolderInfo info =  (IValueHolderInfo) attributes.get(key);
-        
-        if (info != null)
-        {
-            return info;
-        }
-        Object value = attributes.get("value"); //$NON-NLS-1$
-        if (value != null)
-        {
-            Object converter = attributes.get("converter"); //$NON-NLS-1$
-            Object localValue = attributes.get("localValue"); //$NON-NLS-1$
-            
-            return new ValueHolderInfo((ConverterDecorator) converter, localValue, value);
-        }
-        return null;
-    }
-    
-    // @Override
-    protected String getMostSpecificComponentName() {
-        return "UIOutput"; //$NON-NLS-1$
-    }
-
-    public final ConverterDecorator getConverter() {
-        // should only be a single converter decorator...
-        // so on this interface we'll return the first one if present.
-        // to do things like error checking, use the getDecorator
-        final List converters = getDecorators(ComponentFactory.CONVERTER);
-
-        if (converters.size() > 0) {
-            return (ConverterDecorator) converters.get(0);
-        }
-
-        return null;
-    }
-
-    public final Object getLocalValue() {
-        return _localValue;
-    }
-
-    public final Object getValue() {
-        return _value;
-    }
-}
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/datatypes/ELExpression.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/datatypes/ELExpression.java
deleted file mode 100644
index b14f68d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/datatypes/ELExpression.java
+++ /dev/null
@@ -1,25 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.datatypes;
-
-/**
- * An abstraction for an EL expression.
- * 
- * @author cbateman
- * 
- */
-public abstract class ELExpression
-{
-    /**
-     * @return the original text of EL expression
-     */
-    public abstract String getText();
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/ActionListenerDecorator.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/ActionListenerDecorator.java
deleted file mode 100644
index 6c7993e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/ActionListenerDecorator.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.decorator;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentInfo;
-
-/**
- * Design time ActionListener decorator
- * 
- * @author cbateman
- *
- */
-public class ActionListenerDecorator extends ComponentDecorator {
-
-    /**
-     * 
-     */
-    private static final long serialVersionUID = 3806862878381550874L;
-
-    /**
-     * @param decorates
-     */
-    public ActionListenerDecorator(final ComponentInfo decorates) {
-        super(decorates);
-    }
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/ComponentDecorator.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/ComponentDecorator.java
deleted file mode 100644
index b700073..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/ComponentDecorator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.decorator;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentInfo;
-
-/**
- * @author cbateman
- *
- */
-public abstract class ComponentDecorator extends Decorator 
-{
-    /**
-     * 
-     */
-    private static final long serialVersionUID = 4378142984217256364L;
-    
-    private final ComponentInfo     _decorates;
-    
-    /**
-     * @param decorates
-     */
-    public ComponentDecorator(final ComponentInfo decorates)
-    {
-        _decorates = decorates;
-    }
-
-    /**
-     * @return the component that this decorator decorates.
-     */
-    public final ComponentInfo getDecorates() {
-        return _decorates;
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/ConverterDecorator.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/ConverterDecorator.java
deleted file mode 100644
index 692ec3b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/ConverterDecorator.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.decorator;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentInfo;
-
-/**
- * A converter decorator.
- * 
- * @author cbateman
- *
- */
-public class ConverterDecorator extends ComponentDecorator {
-
-    private final ConverterTypeInfo     _typeInfo;
-    
-    /**
-     * serializable id
-     */
-    private static final long serialVersionUID = 3838224353030247227L;
-    
-    
-    /**
-     * @param decorates
-     * @param typeInfo
-     */
-    public ConverterDecorator(final ComponentInfo decorates, final ConverterTypeInfo typeInfo)
-    {
-        super(decorates);
-        _typeInfo = typeInfo;
-    }
-
-    /**
-     * @return the converter's type info.
-     */
-    public final ConverterTypeInfo getTypeInfo()
-    {
-        return _typeInfo;
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/ConverterTypeInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/ConverterTypeInfo.java
deleted file mode 100644
index f013d3c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/ConverterTypeInfo.java
+++ /dev/null
@@ -1,146 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.decorator;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.types.ClassTypeInfo;
-
-/**
- * Type information about a converter.
- * 
- * @author cbateman
- * 
- */
-public class ConverterTypeInfo extends ClassTypeInfo
-{
-    /**
-     * serializable id
-     */
-    private static final long serialVersionUID = -7238952424045449907L;
-    private static final String[]  NO_FOR_CLASS = new  String[0];
-    private final String        _converterId;
-    private final String[]      _forClasses;
-
-    /**
-     * For unknown converters, use the UNKNOWN constant.
-     * 
-     * @param className
-     * @param converterId
-     * @throws java.lang.IllegalArgumentException
-     *             if both className and converterId are null.
-     * 
-     */
-    public ConverterTypeInfo(String className, String converterId)
-    {
-        super(className, new String[0], new String[0]);
-        if (className == null && converterId == null)
-        {
-            throw new IllegalArgumentException(
-                    "converterClass and converterId must not both be null.  For unknown validator use the UNKNOWN constant"); //$NON-NLS-1$
-        }
-
-        _converterId = converterId;
-        _forClasses = NO_FOR_CLASS;
-    }
-
-    /**
-     * For unknown converters, use the UNKNOWN constant.
-     * 
-     * @param className
-     * @param superClasses 
-     * @param interfaces 
-     * @param converterId
-     * @param forClass 
-     * @throws java.lang.IllegalArgumentException
-     *             if both className and converterId are null.
-     * 
-     */
-    public ConverterTypeInfo(String className, String[] superClasses,
-            String[] interfaces, String converterId, String[] forClass)
-    {
-        super(className, superClasses, interfaces);
-        if (className == null && converterId == null)
-        {
-            throw new IllegalArgumentException(
-                    "converterClass and converterId must not both be null.  For unknown validator use the UNKNOWN constant"); //$NON-NLS-1$
-        }
-
-        _converterId = converterId;
-        if (forClass == null)
-        {
-            _forClasses = NO_FOR_CLASS;
-        }
-        else
-        {
-            _forClasses = forClass;
-        }
-    }
-
-    /**
-     * Use when the converter's information unknown such as occurs when using
-     * the f:converter tag.
-     */
-    public static final ConverterTypeInfo UNKNOWN = new ConverterTypeInfo(
-            (Object) null);
-
-    /**
-     * A private constructor used to create the UNRESOLVED constant. We use an
-     * Object arg here (which is discarded) rather than using the zero-arg
-     * constructor so as not mess up anything like Serializable that may depend
-     * on how zero-arg constructors are defined.
-     * 
-     * @param unresolved
-     */
-    private ConverterTypeInfo(Object unresolved)
-    {
-        super(null, new String[0], new String[0]);
-        _converterId = null;
-        _forClasses = NO_FOR_CLASS;
-    }
-
-    /**
-     * @return the converter's id.
-     */
-    public final String getConverterId()
-    {
-        return _converterId;
-    }
-
-    /**
-     * @return a copy of the listof classes that this type converters to.  May
-     * be empty.  Never null.
-     */
-    public final String[] getForClass()
-    {
-        final String[]  returnArray = new String[_forClasses.length];
-        System.arraycopy(_forClasses, 0, returnArray, 0, _forClasses.length);
-        return returnArray;
-    }
-
-    public String toString()
-    {
-        String toString = ""; //$NON-NLS-1$
-
-        if (_forClasses.length  > 0)
-        {
-            toString = "For-Classes: ["; //$NON-NLS-1$
-            for (int i = 0; i < _forClasses.length; i++)
-            {
-                toString += _forClasses[i];
-                if (i < _forClasses.length-1)
-                {
-                    toString += ", "; //$NON-NLS-1$
-                }
-            }
-            toString += "], "; //$NON-NLS-1$
-        }
-        return toString + "Converter Type Info: type = " + _converterId + ", "+super.toString(); //$NON-NLS-1$ //$NON-NLS-2$
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/Decorator.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/Decorator.java
deleted file mode 100644
index ceaae4e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/Decorator.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.decorator;
-
-import java.io.Serializable;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.ViewObject;
-
-/**
- * The abstract super-class of all view object decorators.
- * 
- * @author cbateman
- * 
- */
-public abstract class Decorator extends ViewObject implements Serializable
-{
-
-    /**
-     * serializable id
-     */
-    private static final long serialVersionUID = -3138829736243154022L;
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/FacetDecorator.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/FacetDecorator.java
deleted file mode 100644
index 32e7f0d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/FacetDecorator.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.decorator;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentInfo;
-
-/**
- * Component decorator for facets.
- * 
- * @author cbateman
- *
- */
-public class FacetDecorator extends ComponentDecorator 
-{
-    /**
-     * 
-     */
-    private static final long serialVersionUID = 94806944978127012L;
-
-    private final String _name;
-
-    /**
-     * @param name
-     * @param component
-     */
-    public FacetDecorator(final String name, final ComponentInfo component) {
-        super(component);
-        _name = name;
-    }
-
-    /**
-     * @return the name of the facet.
-     */
-    public final String getName() {
-        return _name;
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/ValidatorDecorator.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/ValidatorDecorator.java
deleted file mode 100644
index b7e33d0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/ValidatorDecorator.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.decorator;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentInfo;
-
-/**
- * Validator decorator.
- * 
- * @author cbateman
- *
- */
-public class ValidatorDecorator extends ComponentDecorator {
-    /**
-     * 
-     */
-    private static final long serialVersionUID = -2898015711621314782L;
-
-    private final ValidatorTypeInfo     _typeInfo;
-
-    /**
-     * @param decorates
-     * @param typeInfo
-     */
-    public ValidatorDecorator(final ComponentInfo decorates, final ValidatorTypeInfo typeInfo) {
-        super(decorates);
-        _typeInfo = typeInfo;
-    }
-
-    /**
-     * @return the validator's type info
-     */
-    public final ValidatorTypeInfo getTypeInfo()
-    {
-        return _typeInfo;
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/ValidatorTypeInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/ValidatorTypeInfo.java
deleted file mode 100644
index 7e4a6fc..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/ValidatorTypeInfo.java
+++ /dev/null
@@ -1,103 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.decorator;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.types.ClassTypeInfo;
-
-/**
- * Type information about validator decorator.
- * @author cbateman
- *
- */
-public class ValidatorTypeInfo extends ClassTypeInfo
-{
-    /**
-     * 
-     */
-    private static final long serialVersionUID = 7512992316792276160L;
-    private final String    _validatorId;
-
-    /**
-     * For unknown validators, use the UNKNOWN constant.
-     * 
-     * @param validatorClass
-     * @param validatorId
-     * @throws java.lang.IllegalArgumentException if both className and
-     * converterId are null.
-     * 
-     */
-    public ValidatorTypeInfo(String validatorClass, String validatorId)
-    {
-        super(validatorClass, new String[0], new String[0]);
-        
-        if (validatorClass == null && validatorId == null)
-        {
-            throw new IllegalArgumentException("validatorClass and validatorId must not both be null.  For unknown validator use the UNKNOWN constant"); //$NON-NLS-1$
-        }
-        _validatorId = validatorId;
-    }
-
-    /**
-     * For unknown validators, use the UNKNOWN constant.
-     * 
-     * @param validatorClass
-     * @param superClasses 
-     * @param interfaces 
-     * @param validatorId
-     * @throws java.lang.IllegalArgumentException if both className and
-     * converterId are null.
-     * 
-     */
-    public ValidatorTypeInfo(String validatorClass, String[] superClasses, String[] interfaces, String validatorId)
-    {
-        super(validatorClass, superClasses, interfaces);
-        
-        if (validatorClass == null && validatorId == null)
-        {
-            throw new IllegalArgumentException("validatorClass and validatorId must not both be null.  For unknown validator use the UNKNOWN constant"); //$NON-NLS-1$
-        }
-        _validatorId = validatorId;
-    }
-
-    /**
-     * Use when a validator's type info information is unknown.
-     */
-    public static final ValidatorTypeInfo  UNKNOWN = 
-        new ValidatorTypeInfo((Object)null);
-    
-    /**
-     * A private constructor used to create the UNRESOLVED constant.
-     * We use an Object arg here (which is discarded) rather than using
-     * the zero-arg constructor so as not mess up anything like Serializable
-     * that may depend on how zero-arg constructors are defined.
-     * 
-     * @param unresolved
-     */
-    private ValidatorTypeInfo(Object unresolved)
-    {
-        super(null, new String[0], new String[0]);
-        _validatorId = null;
-    }
-
-    /**
-     * @return the validator id (may be null if unknown).
-     */
-    public final String getValidatorId()
-    {
-        return _validatorId;
-    }
-    
-    public String toString()
-    {
-        return "Validator Type Info: type = " + _validatorId + ", "+super.toString(); //$NON-NLS-1$ //$NON-NLS-2$
-    }
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/ValueChangeListenerDecorator.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/ValueChangeListenerDecorator.java
deleted file mode 100644
index e344c1e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/decorator/ValueChangeListenerDecorator.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.decorator;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentInfo;
-import org.eclipse.jst.jsf.common.runtime.internal.model.event.IValueChangeListenerInfo;
-
-/**
- * ValueChangeListener component decorator.
- * 
- * @author cbateman
- *
- */
-public class ValueChangeListenerDecorator extends ComponentDecorator implements
-        IValueChangeListenerInfo 
-{
-    /**
-     * serializable id
-     */
-    private static final long serialVersionUID = 9045831927898936727L;
-
-    /**
-     * @param decorates
-     */
-    public ValueChangeListenerDecorator(ComponentInfo decorates) {
-        super(decorates);
-    }    
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/event/IActionListenerInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/event/IActionListenerInfo.java
deleted file mode 100644
index a26b3a1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/event/IActionListenerInfo.java
+++ /dev/null
@@ -1,21 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.event;
-
-/**
- * A design time analog for the ActionListener
- * @author cbateman
- *
- */
-public interface IActionListenerInfo extends IFacesListenerInfo 
-{
-    // TODO:
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/event/IFacesListenerInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/event/IFacesListenerInfo.java
deleted file mode 100644
index b8996d4..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/event/IFacesListenerInfo.java
+++ /dev/null
@@ -1,21 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.event;
-
-/**
- * A design-time analog for the runtime Faces Listener.
- * @author cbateman
- *
- */
-public interface IFacesListenerInfo 
-{
-    // no methods
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/event/IValueChangeListenerInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/event/IValueChangeListenerInfo.java
deleted file mode 100644
index 3d21a7a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/event/IValueChangeListenerInfo.java
+++ /dev/null
@@ -1,21 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.event;
-
-/**
- * A design time analog for the runtime ValueChangeListener interface.
- * 
- * @author cbateman
- *
- */
-public interface IValueChangeListenerInfo extends IFacesListenerInfo {
-    // TODO:
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/types/ClassTypeInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/types/ClassTypeInfo.java
deleted file mode 100644
index 4a39bc0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/types/ClassTypeInfo.java
+++ /dev/null
@@ -1,137 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.types;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
-
-/**
- * A type info that has class information.
- * 
- * @author cbateman
- *
- */
-public abstract class ClassTypeInfo extends TypeInfo implements IClassTypeInfo
-{
-    /**
-     * serializable id
-     */
-    private static final long serialVersionUID = -5046230589012357680L;
-
-    /**
-     * the fully qualified class name of the implementation class for this
-     * type.
-     */
-    protected final String _className;
-
-    /**
-     * known super classes of the component class
-     */
-    protected final String[] _superClasses;
-    
-    /**
-     * known interfaces implemented by the component class
-     */
-    protected final String[] _interfaces;
-    
-    /**
-     * used internally by isInstanceOf
-     */
-    private Set            _superTypes; // may be lazily constructed
-    
-
-    /**
-     * @param className 
-     * @param superClasses
-     * @param interfaces
-     */
-    protected ClassTypeInfo(final String className, final String[] superClasses, final String[] interfaces)
-    {
-        _className = className;
-        _superClasses = superClasses != null ? superClasses : new String[0];
-        _interfaces = interfaces != null ? interfaces : new String[0];
-        
-        if (_superClasses.length + _interfaces.length == 0)
-        {
-            // there are no super-types known
-            _superTypes = Collections.EMPTY_SET;
-        }
-    }
-    
-    public final String[] getInterfaces()
-    {
-        if (_interfaces.length > 0)
-        {
-            final String[]  copy =  new String[_interfaces.length];
-            System.arraycopy(_interfaces, 0, copy, 0, _interfaces.length);
-            return copy;
-        }
-        return new String[0];
-    }
-
-    public final String[] getSuperClasses()
-    {
-        if (_superClasses.length > 0)
-        {
-            final String[]  copy =  new String[_superClasses.length];
-            System.arraycopy(_superClasses, 0, copy, 0, _superClasses.length);
-            return copy;
-        }
-        return new String[0];
-    }
-
-    public final boolean isInstanceOf(String checkType)
-    {
-        if (_superTypes == null)
-        {
-            _superTypes = new HashSet();
-            _superTypes.addAll(Arrays.asList(_superClasses));
-            _superTypes.addAll(Arrays.asList(_interfaces));
-        }
-        
-        return _superTypes.contains(checkType);
-    }
-
-    public final String getClassName()
-    {
-        return _className;
-    }
-
-    public String toString()
-    {
-        String supers = "["; //$NON-NLS-1$
-        
-        for (int i = 0; i < _superClasses.length; i++)
-        {
-            supers += _superClasses[i];
-            
-            if (i < _superClasses.length)
-            {
-                supers += ","; //$NON-NLS-1$
-            }
-        }
-        
-        for (int i = 0; i < _interfaces.length; i++)
-        {
-            supers += _interfaces[i];
-            
-            if (i < _interfaces.length-1)
-            {
-                supers += ","; //$NON-NLS-1$
-            }
-        }
-        supers +="]"; //$NON-NLS-1$
-        
-        return "class= "+getClassName()+ ", supers="+ supers; //$NON-NLS-1$ //$NON-NLS-2$
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/types/IAttributeValueProxy.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/types/IAttributeValueProxy.java
deleted file mode 100644
index 95b83db..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/types/IAttributeValueProxy.java
+++ /dev/null
@@ -1,23 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.types;
-
-import java.io.Serializable;
-
-/**
- * Wraps 
- * @author cbateman
- *
- */
-public interface IAttributeValueProxy extends Serializable
-{
-//
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/types/IClassTypeInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/types/IClassTypeInfo.java
deleted file mode 100644
index 7b43252..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/types/IClassTypeInfo.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.types;
-
-/**
- * A type info that has an associate Java class.
- * @author cbateman
- *
- */
-public interface IClassTypeInfo
-{
-    /**
-     * The fully qualified class name, i.e. java.lang.String
-     * 
-     * @return the fully qualified class name in dot notation
-     * 
-     */
-    String getClassName();
-    
-    /**
-     * Should never return null.  Return empty array if none.
-     * 
-     * @return the list of fully-qualified super class names.  List is as 
-     * calculated at IClassTypeInfo construction and no guarantee is made
-     * (although an implementer may do so) that it will be updated if the
-     * definition of className changes.
-     */
-    String[]  getSuperClasses();
-    
-    /**
-     * Should never return null.  Return empty array if none.
-     * 
-     * @return the list of fully-qualified interface names.  List is as 
-     * calculated at IClassTypeInfo construction and no guarantee is made
-     * (although an implementer may do so) that it will be updated if the
-     * definition of className changes.
-     */
-    String[]  getInterfaces();
-    
-    /**
-     * @param checkType
-     * @return true if checkType is in the set comprised of getSuperClasses()+getInterfaces()
-     */
-    boolean isInstanceOf(final String checkType);
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/types/TypeInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/types/TypeInfo.java
deleted file mode 100644
index 4061f4a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/types/TypeInfo.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.model.types;
-
-import java.io.Serializable;
-
-/**
- * Abstract super-class of all view object type information objects.
- * 
- * @author cbateman
- *
- */
-public abstract class TypeInfo implements Serializable
-{
-    /**
-     * serializable id
-     */
-    private static final long serialVersionUID = -3653573923653759724L;
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/AbstractTagAttribute.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/AbstractTagAttribute.java
deleted file mode 100644
index 696113a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/AbstractTagAttribute.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package org.eclipse.jst.jsf.common.runtime.internal.view.model.common;
-
-/**
- * Super-class of all ITagAttribute concrete implementations.
- * 
- * @author cbateman
- *
- */
-public abstract class AbstractTagAttribute implements ITagAttribute
-{
-    /**
-     * 
-     */
-    private static final long serialVersionUID = 6364594863141579928L;
-
-    public abstract String getName();
-
-    public abstract String getTargetNamespace();
-
-    public abstract String getDescription();
-
-    public abstract String getDisplayName();
-
-    public abstract boolean isRequired();
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/ComponentPropertyHandler.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/ComponentPropertyHandler.java
deleted file mode 100644
index aa50545..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/ComponentPropertyHandler.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Cameron Bateman - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.view.model.common;
-
-/**
- * Default implementation of IComponentPropertyHandler.
- * 
- * @author cbateman
- * 
- */
-public class ComponentPropertyHandler extends TagAttributeHandler implements
-        IComponentPropertyHandler
-{
-    /**
-     * 
-     */
-    private static final long serialVersionUID = 8614562842401106572L;
-    private final String  _propertyName;
-
-    /**
-     * @param customHandler
-     * @param name
-     * @param elAllowed
-     * @param propertyName
-     */
-    public ComponentPropertyHandler(final String customHandler,
-            final String name, final boolean elAllowed,
-            final String propertyName)
-    {
-        super(customHandler, name, elAllowed);
-        _propertyName = propertyName;
-    }
-
-    public String getPropertyName()
-    {
-        return _propertyName;
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/IComponentPropertyHandler.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/IComponentPropertyHandler.java
deleted file mode 100644
index dfcaf79..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/IComponentPropertyHandler.java
+++ /dev/null
@@ -1,25 +0,0 @@
-/*******************************************************************************
- * Copyright (c) ${year} Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Cameron Bateman - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.common.runtime.internal.view.model.common;
-
-/**
- * Maps tag attributes to component properties.
- * 
- * @author cbateman
- *
- */
-public interface IComponentPropertyHandler extends ITagAttributeHandler
-{
-    /**
-     * @return the property name that this handler maps to.
-     */
-    String getPropertyName();
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/IComponentTagElement.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/IComponentTagElement.java
deleted file mode 100644
index d34cb2f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/IComponentTagElement.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.view.model.common;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentTypeInfo;
-
-/**
- * A JSF tag element that maps one-to-one to a JSF UIComponent
- * 
- * @author cbateman
- *
- */
-public interface IComponentTagElement extends IJSFTagElement 
-{
-    /**
-     * @return the comopnent's type info.
-     */
-    ComponentTypeInfo getComponent();
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/IConverterTagElement.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/IConverterTagElement.java
deleted file mode 100644
index 63e43ad..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/IConverterTagElement.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.view.model.common;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ConverterTypeInfo;
-
-/**
- * A tag element that causes the construction registration of a converter on
- * a parent object.
- * 
- * @author cbateman
- *
- */
-public interface IConverterTagElement extends IJSFTagElement
-{
-    /**
-     * @return the type info for the converter represented by this
-     * element
-     */
-    ConverterTypeInfo getConverter();
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/IHandlerTagElement.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/IHandlerTagElement.java
deleted file mode 100644
index 43e6828..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/IHandlerTagElement.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.view.model.common;
-
-import java.io.Serializable;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.types.TypeInfo;
-
-/**
- * Generic tag handler that has effect when processed by the JSF ViewHandler.
- * 
- * @author cbateman
- *
- */
-public interface IHandlerTagElement extends IJSFTagElement
-{
-    /**
-     * Enumerates known types of built-in tag handlers.
-     * 
-     * @author cbateman
-     *
-     */
-    static class TagHandlerType extends TypeInfo implements Serializable
-    {
-        /**
-         * serializable id
-         */
-        private static final long serialVersionUID = 5062853948108253861L;
-        
-        private final static int HANDLER_TYPE_FACET = 0;
-        private final static int HANDLER_TYPE_ACTIONLISTENER = 1;
-        private final static int HANDLER_TYPE_VALUECHANGELISTENER = 2;
-        private final static int HANDLER_TYPE_ATTRIBUTE = 3;
-
-        private final static String[]  strValues =
-            {"facet", "actionListener", "valueChangeListener"}; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-
-        private final int _intValue;
-        
-        public TagHandlerType(int intValue)
-        {
-            _intValue = intValue;
-        }
-
-        public String toString()
-        {
-            return strValues[_intValue];
-        }
-
-        protected final int intValue()
-        {
-            return _intValue;
-        }
-       
-        public final static TagHandlerType FACET = 
-            new TagHandlerType(HANDLER_TYPE_FACET);
-        public final static TagHandlerType ACTIONLISTENER = 
-            new TagHandlerType(HANDLER_TYPE_ACTIONLISTENER);
-        public final static TagHandlerType VALUECHANGELISTENER = 
-            new TagHandlerType(HANDLER_TYPE_VALUECHANGELISTENER);
-        public final static TagHandlerType ATTRIBUTE = 
-            new TagHandlerType(HANDLER_TYPE_ATTRIBUTE);
-        
-    }
-    
-    /**
-     * @return the tag handler type as defined by standard known types of 
-     * tags that do not (necessarily) translate into standard objects at 
-     * runtime but may modify the view in some way.
-     */
-    TagHandlerType getTagHandlerType();
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/IJSFTagElement.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/IJSFTagElement.java
deleted file mode 100644
index 435c08a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/IJSFTagElement.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.view.model.common;
-
-import java.io.Serializable;
-
-/**
- * An abstraction of a tag element that maps to a JSF artifact (i.e. component, validator)
- *
- * @author cbateman
- *
- */
-public interface IJSFTagElement extends ITagElement
-{
-    /**
-     * An enumeration of different kinds of tags.
-     * 
-     * @author cbateman
-     *
-     */
-    static class TagType implements Serializable
-    {
-        /**
-         * serializable id
-         */
-        private static final long serialVersionUID = -2845327764902349963L;
-        private final static int TYPE_COMPONENT = 0;
-        private final static int TYPE_CONVERTER = 1;
-        private final static int TYPE_VALIDATOR = 2;
-        private final static int TYPE_HANDLER = 3;
-        //private final static int TYPE_UNKNOWN = 4;
-
-        private final static String[]  strValues =
-            {"component", "converter", "validator", "handler"}; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-
-        private final int _intValue;
-        
-        public TagType(int intValue)
-        {
-            _intValue = intValue;
-        }
-
-        public String toString()
-        {
-            return strValues[_intValue];
-        }
-
-        protected final int intValue()
-        {
-            return _intValue;
-        }
-       
-        public final static TagType COMPONENT = 
-            new TagType(TYPE_COMPONENT);
-        public final static TagType CONVERTER = 
-            new TagType(TYPE_CONVERTER);
-        public final static TagType VALIDATOR = 
-            new TagType(TYPE_VALIDATOR);
-        public final static TagType HANDLER = 
-            new TagType(TYPE_HANDLER);
-    }
-    
-    /**
-     * @return the type of tag as distinguished by how it may affect the
-     * view at runtime.
-     */
-    TagType getType();
-}
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/ITagAttribute.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/ITagAttribute.java
deleted file mode 100644
index 52fd6c2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/ITagAttribute.java
+++ /dev/null
@@ -1,40 +0,0 @@
-package org.eclipse.jst.jsf.common.runtime.internal.view.model.common;
-
-import java.io.Serializable;
-
-/**
- * Information about a tags attribute
- * @author cbateman
- *
- */
-public interface ITagAttribute extends Serializable
-{
-    /**
-     * @return the name of the attribute.  In XML this is the "local" name of
-     * the attribute: that is, it's name without any namespace qualification.
-     */
-    String getName();
-    
-    /**
-     * @return the unique namespace of the attribute or null if it is always the
-     * same as it's owner (the typical case in JSF).
-     */
-    String getTargetNamespace();
-    
-    /**
-     * @return a long-form piece of text, intended for end-user consumption,
-     * that describes the attribute
-     */
-    String getDescription();
-    
-    /**
-     * @return a short, user visible label text for the attribute.
-     */
-    String getDisplayName();
-    
-    /**
-     * @return true if the attribute is required to be populated on the 
-     * element.
-     */
-    boolean isRequired();
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/ITagAttributeHandler.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/ITagAttributeHandler.java
deleted file mode 100644
index f6d15c9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/ITagAttributeHandler.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*******************************************************************************
- * Copyright (c) ${year} Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Cameron Bateman - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.common.runtime.internal.view.model.common;
-
-import java.io.Serializable;
-
-/**
- * Basic information on attributes.
- * TODO C.B: some question exists in my mind as to how/whether this should merge
- * with meta-data enabled type descriptors.
- * 
- * @author cbateman
- *
- */
-public interface ITagAttributeHandler extends Serializable
-{
-    /**
-     * @return the name of the attribute
-     */
-    String      getName();
-    /**
-     * @return the name of an extension point used to perform custom handling
-     * of the attribute.
-     */
-    String      getCustomHandler();
-    
-    /**
-     * @return true if the property allows EL expressions
-     */
-    boolean isELAllowed();
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/ITagElement.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/ITagElement.java
deleted file mode 100644
index e4d8298..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/ITagElement.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.view.model.common;
-
-import java.io.Serializable;
-import java.util.Map;
-
-/**
- * Super-interface of all JSF tag elements.
- * 
- * @author cbateman
- *
- */
-public interface ITagElement extends Serializable
-{
-
-    /**
-     * @return the name of the tag
-     */
-    public abstract String getName();
-
-    /**
-     * @return the namespace uri for this tag
-     */
-    public abstract String getUri();
-    
-    /**
-     * @return the fully qualified class name in dot separated format
-     * (i.e. javax.faces.webapp.ConverterTag)
-     */
-    public abstract String getTagHandlerClassName();
-    
-    /**
-     * @return an unmodifiable map, indexed by name, of all the attribute
-     * handlers available for this tag element.  Each value in the Map
-     * must be a ITagAttributeHandler.
-     */
-    public abstract Map    getAttributeHandlers();
-
-    /**
-     * @return the attributes for the tag.
-     */
-    public abstract Map<String, ? extends ITagAttribute> getAttributes();
-    /**
-     * Signals that the tag element should  make any mutable data immutable
-     * and throw exceptions if attempts are made to implement.  Flag must
-     * latch and become irrevocable.
-     */
-//    public abstract void setLocked();
-    
-    /**
-     * @return true if setLocked has been called.
-     */
-//    public abstract boolean isLocked();
-}
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/IValidatorTagElement.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/IValidatorTagElement.java
deleted file mode 100644
index 9474902..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/IValidatorTagElement.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.view.model.common;
-
-import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ValidatorTypeInfo;
-
-/**
- * Represents a tag element for a JSF validator.
- * 
- * @author cbateman
- *
- */
-public interface IValidatorTagElement extends IJSFTagElement
-{
-    /**
-     * @return the type info about the validator.
-     */
-    ValidatorTypeInfo getValidator();
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/Namespace.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/Namespace.java
deleted file mode 100644
index ee0259f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/Namespace.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.view.model.common;
-
-import java.io.Serializable;
-import java.util.Collection;
-
-/**
- * Abstracts an xml namespace used to define a set of view tags
- * 
- */
-public abstract class Namespace implements Serializable
-{
-    /**
-     * 
-     */
-    private static final long serialVersionUID = 6386464282396970948L;
-
-    /**
-     * @return the namespace uri. MUST NOT BE NULL
-     */
-    public abstract String getNSUri();
-
-    /**
-     * This call may be long running.  Call isInitialized to determine if all 
-     * information is already cached, or if calling this method is likely
-     * to take a long time.
-     * 
-     * @return the view elements in this namespace. May be empty but MUST NOT BE
-     *         NULL.
-     */
-    public abstract Collection<? extends ITagElement> getViewElements();
-    
-    /**
-     * This method should be light weight if possible.  Unlike calling
-     * getViewElements().isEmpty, this call should not require that all
-     * view element children of this namespace be analyzed and constructed in
-     * order to succeed.
-     * 
-     * @return true if this name space has view element children
-     */
-    public abstract boolean hasViewElements();
-
-    /**
-     * If calculating all view elements is expensive, a Namespace implementation
-     * may defer calculation until a specific element is requested.  A caller of
-     * getViewElements (such as a UI that shows all tags), may wish to know if
-     * the entire namespace has been initialized before calling it, since it may
-     * be long running.
-     * 
-     * @return true if the namespace's elements have been fully initialized.  If this
-     * method returns false, care should be taken in calling getViewElements() and
-     * getViewElement() since they may be very long running.
-     */
-    public abstract boolean isInitialized();
-    
-    /**
-     * @param name
-     * @return the tag element called 'name' or null if none.
-     */
-    public abstract ITagElement getViewElement(final String name);
-
-    /**
-     * @return a user readable display name for this namespace or null if none.
-     */
-    public abstract String getDisplayName();
-
-    public String toString()
-    {
-        return getNSUri();
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/TagAttributeHandler.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/TagAttributeHandler.java
deleted file mode 100644
index b293495..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/TagAttributeHandler.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*******************************************************************************
- * Copyright (c) ${year} Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Cameron Bateman - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.view.model.common;
-
-/**
- * Default implementation of ITagAttributeHandler.
- * 
- * @author cbateman
- * 
- */
-public class TagAttributeHandler implements ITagAttributeHandler
-{
-    /**
-     * 
-     */
-    private static final long serialVersionUID = 8153903018703133004L;
-    private final String      _customHandler;
-    private final String      _name;
-    private final boolean     _elAllowed;
-
-    /**
-     * @param customHandler
-     * @param name
-     * @param elAllowed
-     */
-    public TagAttributeHandler(final String customHandler, final String name,
-            final boolean elAllowed)
-    {
-        super();
-        _customHandler = customHandler;
-        _elAllowed = elAllowed;
-        _name = name;
-    }
-
-    public String getCustomHandler()
-    {
-        return _customHandler;
-    }
-
-    public String getName()
-    {
-        return _name;
-    }
-
-    public boolean isELAllowed()
-    {
-        return _elAllowed;
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/TagElement.java b/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/TagElement.java
deleted file mode 100644
index fb04e6f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/view/model/common/TagElement.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.runtime.internal.view.model.common;
-
-import java.util.Map;
-
-/**
- * Abstract a tag element used to construct a view element
- * 
- * @author cbateman
- *
- */
-public abstract class TagElement implements ITagElement 
-{
-    /**
-     * 
-     */
-    private static final long serialVersionUID = 7885641652240047924L;
-
-    /* (non-Javadoc)
-     * @see viewhandlerprototype.model.ITagElement#getName()
-     */
-    public abstract String getName();
-
-    
-    /* (non-Javadoc)
-     * @see org.eclipse.jst.jsf.common.runtime.internal.view.model.common.ITagElement#getUri()
-     */
-    public abstract String getUri();
-
-    /* (non-Javadoc)
-     * @see org.eclipse.jst.jsf.common.runtime.internal.view.model.common.ITagElement#getTagHandlerClassName()
-     */
-    public abstract String getTagHandlerClassName();
-
-    /* (non-Javadoc)
-     * @see org.eclipse.jst.jsf.common.runtime.internal.view.model.common.ITagElement#getAttributeHandlers()
-     */
-    public abstract Map getAttributeHandlers();
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/.classpath b/jsf/plugins/org.eclipse.jst.jsf.common.ui/.classpath
deleted file mode 100644
index 304e861..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/.classpath
+++ /dev/null
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
-	<classpathentry kind="output" path="bin"/>
-</classpath>
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/.cvsignore b/jsf/plugins/org.eclipse.jst.jsf.common.ui/.cvsignore
deleted file mode 100644
index 2a89e4b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/.cvsignore
+++ /dev/null
@@ -1,4 +0,0 @@
-bin
-@dot
-build.xml
-javaCompiler...args
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/.project b/jsf/plugins/org.eclipse.jst.jsf.common.ui/.project
deleted file mode 100644
index 9615dd9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/.project
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jst.jsf.common.ui</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/jsf/plugins/org.eclipse.jst.jsf.common.ui/.settings/org.eclipse.jdt.core.prefs b/jsf/plugins/org.eclipse.jst.jsf.common.ui/.settings/org.eclipse.jdt.core.prefs
deleted file mode 100644
index 9334e13..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/.settings/org.eclipse.jdt.core.prefs
+++ /dev/null
@@ -1,82 +0,0 @@
-#Mon Jun 30 15:55:16 PDT 2008
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
-org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.5
-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.doc.comment.support=enabled
-org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.autoboxing=warning
-org.eclipse.jdt.core.compiler.problem.deprecation=error
-org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
-org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
-org.eclipse.jdt.core.compiler.problem.discouragedReference=ignore
-org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore
-org.eclipse.jdt.core.compiler.problem.fatalOptionalError=enabled
-org.eclipse.jdt.core.compiler.problem.fieldHiding=warning
-org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
-org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
-org.eclipse.jdt.core.compiler.problem.forbiddenReference=error
-org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
-org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
-org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=warning
-org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
-org.eclipse.jdt.core.compiler.problem.invalidJavadoc=error
-org.eclipse.jdt.core.compiler.problem.invalidJavadocTags=enabled
-org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef=disabled
-org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef=disabled
-org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=protected
-org.eclipse.jdt.core.compiler.problem.localVariableHiding=warning
-org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
-org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingJavadocComments=warning
-org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=protected
-org.eclipse.jdt.core.compiler.problem.missingJavadocTags=warning
-org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=protected
-org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning
-org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
-org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
-org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=error
-org.eclipse.jdt.core.compiler.problem.nullReference=ignore
-org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
-org.eclipse.jdt.core.compiler.problem.parameterAssignment=ignore
-org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=warning
-org.eclipse.jdt.core.compiler.problem.potentialNullReference=ignore
-org.eclipse.jdt.core.compiler.problem.rawTypeReference=ignore
-org.eclipse.jdt.core.compiler.problem.redundantNullCheck=ignore
-org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=ignore
-org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
-org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
-org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled
-org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
-org.eclipse.jdt.core.compiler.problem.typeParameterHiding=ignore
-org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=ignore
-org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=error
-org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning
-org.eclipse.jdt.core.compiler.problem.unnecessaryElse=warning
-org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=warning
-org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=warning
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable=enabled
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference=enabled
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.unusedImport=error
-org.eclipse.jdt.core.compiler.problem.unusedLabel=warning
-org.eclipse.jdt.core.compiler.problem.unusedLocal=error
-org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
-org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference=enabled
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
-org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=error
-org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
-org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.compiler.source=1.5
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/.settings/org.eclipse.jdt.ui.prefs b/jsf/plugins/org.eclipse.jst.jsf.common.ui/.settings/org.eclipse.jdt.ui.prefs
deleted file mode 100644
index 82eb6c1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/.settings/org.eclipse.jdt.ui.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Fri Apr 06 18:25:15 PDT 2007
-eclipse.preferences.version=1
-org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><templates/>
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/.settings/org.eclipse.pde.prefs b/jsf/plugins/org.eclipse.jst.jsf.common.ui/.settings/org.eclipse.pde.prefs
deleted file mode 100644
index d9b486b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/.settings/org.eclipse.pde.prefs
+++ /dev/null
@@ -1,22 +0,0 @@
-#Fri May 30 11:46:32 PDT 2008
-compilers.f.unresolved-features=1
-compilers.f.unresolved-plugins=1
-compilers.incompatible-environment=1
-compilers.p.build=1
-compilers.p.deprecated=1
-compilers.p.discouraged-class=1
-compilers.p.internal=1
-compilers.p.missing-packages=0
-compilers.p.no-required-att=0
-compilers.p.not-externalized-att=0
-compilers.p.unknown-attribute=1
-compilers.p.unknown-class=1
-compilers.p.unknown-element=1
-compilers.p.unknown-identifier=1
-compilers.p.unknown-resource=1
-compilers.p.unresolved-ex-points=0
-compilers.p.unresolved-import=0
-compilers.s.create-docs=false
-compilers.s.doc-folder=doc
-compilers.s.open-tags=1
-eclipse.preferences.version=1
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/META-INF/MANIFEST.MF b/jsf/plugins/org.eclipse.jst.jsf.common.ui/META-INF/MANIFEST.MF
deleted file mode 100644
index 075c0da..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,36 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: %pluginName
-Bundle-SymbolicName: org.eclipse.jst.jsf.common.ui;singleton:=true
-Bundle-Version: 1.2.0.qualifier
-Bundle-Activator: org.eclipse.jst.jsf.common.ui.JSFUICommonPlugin
-Bundle-Localization: plugin
-Require-Bundle: org.eclipse.ui;bundle-version="[3.2.0,4.0.0)",
- org.eclipse.core.runtime;bundle-version="[3.2.0,4.0.0)",
- org.eclipse.ui.cheatsheets;bundle-version="[3.2.0,4.0.0)",
- org.eclipse.help;bundle-version="[3.2.0,4.0.0)",
- org.eclipse.jdt.core;bundle-version="[3.2.0,4.0.0)",
- org.eclipse.core.resources;bundle-version="[3.2.0,4.0.0)",
- org.eclipse.ui.forms;bundle-version="[3.2.0,4.0.0)",
- org.eclipse.jdt.ui;bundle-version="[3.2.0,4.0.0)",
- org.eclipse.ui.ide;bundle-version="[3.2.0,4.0.0)",
- org.eclipse.draw2d;bundle-version="[3.2.0,4.0.0)",
- org.eclipse.jface.text;bundle-version="[3.2.0,4.0.0)",
- org.eclipse.jst.j2ee;bundle-version="[1.1.0,1.2.0)",
- org.eclipse.wst.common.emf;bundle-version="[1.1.103,2.0.0)",
- org.eclipse.wst.common.project.facet.core;bundle-version="[1.2.0,2.0.0)",
- org.eclipse.emf;bundle-version="[2.2.0,3.0.0)",
- org.eclipse.emf.common;bundle-version="[2.2.0,3.0.0)",
- org.eclipse.jst.jsf.common;bundle-version="[1.0.1,2.0.0)"
-Export-Package: org.eclipse.jst.jsf.common.ui;x-friends:="org.eclipse.jst.pagedesigner,org.eclipse.jst.pagedesigner.jsf.ui",
- org.eclipse.jst.jsf.common.ui.internal.actions;x-friends:="org.eclipse.jst.jsf.facesconfig.ui",
- org.eclipse.jst.jsf.common.ui.internal.dialogfield;x-friends:="org.eclipse.jst.pagedesigner,org.eclipse.jst.pagedesigner.jsf.ui",
- org.eclipse.jst.jsf.common.ui.internal.dialogs;x-friends:="org.eclipse.jst.pagedesigner",
- org.eclipse.jst.jsf.common.ui.internal.form;x-internal=true,
- org.eclipse.jst.jsf.common.ui.internal.guiutils;x-friends:="org.eclipse.jst.pagedesigner",
- org.eclipse.jst.jsf.common.ui.internal.logging;x-friends:="org.eclipse.jst.pagedesigner,org.eclipse.jst.pagedesigner.jsf.ui",
- org.eclipse.jst.jsf.common.ui.internal.preferences;x-internal=true,
- org.eclipse.jst.jsf.common.ui.internal.utils;x-friends:="org.eclipse.jst.pagedesigner,org.eclipse.jst.jsf.facesconfig.ui,org.eclipse.jst.pagedesigner.jsf.ui"
-Bundle-ActivationPolicy: lazy
-Bundle-Vendor: %pluginProvider
-Bundle-RequiredExecutionEnvironment: J2SE-1.5
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/about.html b/jsf/plugins/org.eclipse.jst.jsf.common.ui/about.html
deleted file mode 100644
index 3b20a36..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/about.html
+++ /dev/null
@@ -1,22 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-<body lang="EN-US">
-<h2>About This Content</h2>
- 
-<p>June, 2008</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 1.0 (&quot;EPL&quot;).  A copy of the EPL is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</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.</p>
-
-</body>
-</html>
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/about.ini b/jsf/plugins/org.eclipse.jst.jsf.common.ui/about.ini
deleted file mode 100644
index a21a3ec..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/about.ini
+++ /dev/null
@@ -1,29 +0,0 @@
-# about.ini
-# contains information about a feature
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# "%key" are externalized strings defined in about.properties
-# This file does not need to be translated.
-
-# Property "aboutText" contains blurb for "About" dialog (translated)
-aboutText=%blurb
-
-# Property "windowImage" contains path to window icon (16x16)
-# needed for primary features only
-
-# Property "featureImage" contains path to feature image (32x32)
-featureImage=eclipse32.gif
-
-# Property "aboutImage" contains path to product image (500x330 or 115x164)
-# needed for primary features only
-
-# Property "appName" contains name of the application (translated)
-# needed for primary features only
-
-# Property "welcomePage" contains path to welcome page (special XML-based format)
-# optional
-
-# Property "welcomePerspective" contains the id of the perspective in which the
-# welcome page is to be opened.
-# optional
-
-
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/about.mappings b/jsf/plugins/org.eclipse.jst.jsf.common.ui/about.mappings
deleted file mode 100644
index 29ddddb..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/about.mappings
+++ /dev/null
@@ -1,6 +0,0 @@
-# about.mappings
-# contains fill-ins for about.properties
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# This file does not need to be translated.
-
-0=200509071822
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/about.properties b/jsf/plugins/org.eclipse.jst.jsf.common.ui/about.properties
deleted file mode 100644
index d7849b8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/about.properties
+++ /dev/null
@@ -1,27 +0,0 @@
-###############################################################################
-# Copyright (c) 2004, 2005 Sybase, Inc. and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Sybase, Inc. - initial API and implementation
-###############################################################################
-#
-#
-
-
-# about.properties
-# contains externalized strings for about.ini
-# java.io.Properties file (ISO 8859-1 with "\" escapes)
-# fill-ins are supplied by about.mappings
-# This file should be translated.
-
-blurb=JSF Faces Config Editor \n\
-\n\
-Version: {featureVersion}\n\
-Build id: {0}\n\
-\n\
-(c) Copyright Eclipse contributors and others. 2000, 2004.  All rights reserved.\n\
-Visit http://www.eclipse.org/webtools/jsf
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/build.properties b/jsf/plugins/org.eclipse.jst.jsf.common.ui/build.properties
deleted file mode 100644
index 2524004..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/build.properties
+++ /dev/null
@@ -1,28 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-source.. = src/
-output.. = bin/
-bin.includes = META-INF/,\
-               .,\
-               plugin.xml,\
-               about.html,\
-               about.ini,\
-               about.mappings,\
-               about.properties,\
-               bin/,\
-               build.properties,\
-               default.properties,\
-               eclipse32.gif,\
-               icons/,\
-               plugin.properties,\
-               schema/
-javacSource=1.5
-javacTarget=1.5
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/default.properties b/jsf/plugins/org.eclipse.jst.jsf.common.ui/default.properties
deleted file mode 100644
index 82c5358..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/default.properties
+++ /dev/null
@@ -1,52 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-# This file contains all the Default Preference Settings
-
-####################################################
-# Logging Preference Settings
-####################################################
-
-# Enable/Disable console logging.  
-# Valid values: TRUE, FALSE
-console.logging.on=true
-
-# Maximum log level of console logging.  
-# Valid values: DEBUG, INFO, WARN, ERROR, FATAL
-console.logging.max.level=INFO
-
-# Enable/Disable eclipse logging.  
-# Valid values: TRUE, FALSE
-eclipse.logging.on=true
-
-# Maximum log level of eclipse logging.  
-# Valid values: DEBUG, INFO, WARN, ERROR, FATAL
-eclipse.logging.max.level=INFO
-
-eclipse.pattern=%m
-
-# Enable/Disable file logging.  
-# Valid values: TRUE, FALSE
-file.logging.on=true
-
-# Maximum log level of file logging.  
-# Valid values: DEBUG, INFO, WARN, ERROR, FATAL
-file.logging.max.level=DEBUG
-
-# Clear log file when eclipse restarts.  
-# Valid values: TRUE, FALSE
-file.logging.startup.clear=true
-
-# Location of log file
-file.logging.path=facesconfigeditor.log
-
-# Rollover frequency of log file.  
-# Valid values: DAILY, WEEKLY, MONTHLY
-file.logging.rollover.frequency=DAILY
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/eclipse32.gif b/jsf/plugins/org.eclipse.jst.jsf.common.ui/eclipse32.gif
deleted file mode 100644
index e6ad7cc..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/eclipse32.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/Editor_Help.gif b/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/Editor_Help.gif
deleted file mode 100644
index 03f656f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/Editor_Help.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/FacesConfig_GotoEditor.gif b/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/FacesConfig_GotoEditor.gif
deleted file mode 100644
index 0e5bcf6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/FacesConfig_GotoEditor.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/FacesConfig_Introduction.gif b/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/FacesConfig_Introduction.gif
deleted file mode 100644
index 44cd044..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/FacesConfig_Introduction.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/FacesConfig_Tutorial.gif b/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/FacesConfig_Tutorial.gif
deleted file mode 100644
index ad8e5b6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/FacesConfig_Tutorial.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/PD_Palette_Default.gif b/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/PD_Palette_Default.gif
deleted file mode 100644
index 5e7fb33..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/PD_Palette_Default.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/back_nav_16.gif b/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/back_nav_16.gif
deleted file mode 100644
index 740419b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/back_nav_16.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/configs.gif b/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/configs.gif
deleted file mode 100644
index c984fba..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/configs.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/form_banner.gif b/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/form_banner.gif
deleted file mode 100644
index aebc0b2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/form_banner.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/forward_nav_16.gif b/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/forward_nav_16.gif
deleted file mode 100644
index 7a1511d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/forward_nav_16.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/help.gif b/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/help.gif
deleted file mode 100644
index 9d70301..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/help.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/jsf_converter.gif b/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/jsf_converter.gif
deleted file mode 100644
index 16466ed..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/jsf_converter.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/jsf_validator.gif b/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/jsf_validator.gif
deleted file mode 100644
index 86196e9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/jsf_validator.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/jsf_view.gif b/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/jsf_view.gif
deleted file mode 100644
index c81630a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/jsf_view.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/object.gif b/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/object.gif
deleted file mode 100644
index 061161a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/object.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/overview_obj.gif b/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/overview_obj.gif
deleted file mode 100644
index 03f656f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/overview_obj.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/refresh_nav_16.gif b/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/refresh_nav_16.gif
deleted file mode 100644
index a063c23..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/refresh_nav_16.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/reload_nav_16.gif b/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/reload_nav_16.gif
deleted file mode 100644
index d71dfff..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/reload_nav_16.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/stop_nav_16.gif b/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/stop_nav_16.gif
deleted file mode 100644
index 4eb53ec..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/icons/stop_nav_16.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/plugin.properties b/jsf/plugins/org.eclipse.jst.jsf.common.ui/plugin.properties
deleted file mode 100644
index 3549ea3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/plugin.properties
+++ /dev/null
@@ -1,16 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-
-pluginName=JavaServer Faces Tools - Common UI
-pluginProvider=Eclipse.org
-
-extension-point.name.0 = Introduction Page
-extension-point.name.1 = OverviewPage
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/plugin.xml b/jsf/plugins/org.eclipse.jst.jsf.common.ui/plugin.xml
deleted file mode 100644
index 435be3a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/plugin.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?eclipse version="3.2"?>
-<plugin>
-   <extension-point id="introductionPage" name="%extension-point.name.0" schema="schema/introductionPage.exsd"/>
-   <extension-point id="overviewPage" name="%extension-point.name.1" schema="schema/overviewPage.exsd"/>
-</plugin>
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/schema/introductionPage.exsd b/jsf/plugins/org.eclipse.jst.jsf.common.ui/schema/introductionPage.exsd
deleted file mode 100644
index d147b34..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/schema/introductionPage.exsd
+++ /dev/null
@@ -1,213 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.eclipse.jst.jsf.common.ui">
-<annotation>
-      <appInfo>
-         <meta.schema plugin="org.eclipse.jst.jsf.common.ui" id="introductionPage" name="Introduction Page"/>
-      </appInfo>
-      <documentation>
-         The purpose of this extension point is to allow plug-ins to describe the contents and links on a introduction page of an editor.
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <complexType>
-         <sequence>
-            <element ref="introductionpage"/>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified identifier of the target extension point.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  identifier of the extension instance, this should be the same as the editor id.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  an optional name of the extension instance. Normally this is the editor name.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="introductionpage">
-      <annotation>
-         <documentation>
-            The details for an introduction page for a specific plugins editor
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="introductionelement" minOccurs="1" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="name" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The name of the page.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="description" type="string">
-            <annotation>
-               <documentation>
-                  A description for the page.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="introductionelement">
-      <annotation>
-         <documentation>
-            An element that make up a section of the page. Elements can contain Headers, Hyperlinks, Icons and text.
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="icon" type="string">
-            <annotation>
-               <documentation>
-                  An icon to display in the element. The icon should be 72x72 and will appear to the left of the headers, hyperlinks and text
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="resource"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="heading" type="string">
-            <annotation>
-               <documentation>
-                  A short heading for the element (optional)
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="text" type="string">
-            <annotation>
-               <documentation>
-                  The text description for the element
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="hyperlink" type="string">
-            <annotation>
-               <documentation>
-                  A hyperlink associated with the element. The hyperlink would normally execute the hyperlinkaction action
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="hyperlinkaction" type="string">
-            <annotation>
-               <documentation>
-                  The action associated with the hyperlink. This is an action that will be executed when the hyperlink is selected
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="actionparameters" type="string">
-            <annotation>
-               <documentation>
-                  Can be used to pass one or more parameters to the hyperlink action. Parameter must be space separated (optional)
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="since"/>
-      </appInfo>
-      <documentation>
-         1.0.0
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="examples"/>
-      </appInfo>
-      <documentation>
-         &lt;extension
-         id=&quot;org.eclipse.jst.jsf.facesconfig.ui.pageflow.PageflowEditor&quot;
-         name=&quot;%pageflow.editor.intro.name&quot;
-         point=&quot;org.eclipse.jst.jsf.facesconfig.ui.page.introductionPage&quot;&gt;
-      &lt;introductionpage
-            name=&quot;%pageflow.editor.intro.name&quot;
-            description=&quot;%port.editor.intro.description&quot;&gt;
-         &lt;introductionelement
-               icon=&quot;icons/pageflow_72.gif&quot;
-               heading=&quot;%pageflow.editor.intro.heading&quot;
-               text=&quot;%pageflow.editor.intro.description&quot;&gt;
-         &lt;/introductionelement&gt;
-         &lt;introductionelement
-               actionparameters=&quot;Pageflow.designerCheatSheet&quot;
-               icon=&quot;icons/tutorials_72.gif&quot;
-               hyperlinkaction=&quot;org.eclipse.jst.jsf.common.ui.actions.LoadCheatSheetAction&quot;
-               text=&quot;%pageflow.editor.intro.cheatsheets.text&quot;
-               hyperlink=&quot;%pageflow.editor.intro.cheatsheets.link&quot;&gt;
-         &lt;/introductionelement&gt;
-         &lt;introductionelement
-               actionparameters=&quot;http://www.eclipse.org&quot;
-               icon=&quot;icons/overview_72.gif&quot;
-               hyperlinkaction=&quot;org.eclipse.jst.jsf.common.ui.actions.LoadHelpAction&quot;
-               text=&quot;%pageflow.editor.intro.help.text&quot;
-               hyperlink=&quot;%pageflow.editor.intro.help.link&quot;&gt;
-         &lt;/introductionelement&gt;
-         &lt;introductionelement
-               actionparameters=&quot;overview&quot;
-               icon=&quot;icons/gotoeditor_72.gif&quot;
-               hyperlinkaction=&quot;org.eclipse.jst.jsf.common.ui.actions.OpenPageAction&quot;
-               text=&quot;%pageflow.editor.intro.start.text&quot;
-               hyperlink=&quot;%pageflow.editor.intro.start.link&quot;&gt;
-         &lt;/introductionelement&gt;
-      &lt;/introductionpage&gt;
-   &lt;/extension&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="apiInfo"/>
-      </appInfo>
-      <documentation>
-         
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="implementation"/>
-      </appInfo>
-      <documentation>
-         
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="copyright"/>
-      </appInfo>
-      <documentation>
-         Copyright (c) 2004, 2006 Sybase, Inc. and others. &lt;br&gt;
- All rights reserved. This program and the accompanying materials &lt;br&gt;
- are made available under the terms of the Eclipse Public License v1.0 &lt;br&gt;
- which accompanies this distribution, and is available at &lt;br&gt;
- http://www.eclipse.org/legal/epl-v10.html &lt;br&gt;
- 
-  Contributors: &lt;br&gt;
-      Sybase, Inc. - initial API and implementation &lt;br&gt;
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/schema/overviewPage.exsd b/jsf/plugins/org.eclipse.jst.jsf.common.ui/schema/overviewPage.exsd
deleted file mode 100644
index c55436b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/schema/overviewPage.exsd
+++ /dev/null
@@ -1,213 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.eclipse.jst.jsf.common.ui">
-<annotation>
-      <appInfo>
-         <meta.schema plugin="org.eclipse.jst.jsf.common.ui" id="overviewPage" name="Overview Page"/>
-      </appInfo>
-      <documentation>
-         The purpose of this extension point is to allow plug-ins to describe the contents and links on a overview page of an editor.
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <complexType>
-         <sequence>
-            <element ref="overviewpage"/>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-                  a fully qualified identifier of the target extension point.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string" use="required">
-            <annotation>
-               <documentation>
-                  identifier of the extension instance, this should be the same as the editor id.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  an optional name of the extension instance. Normally this is the editor name.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="overviewpage">
-      <annotation>
-         <documentation>
-            The details for an overview page for a specific plugins editor
-         </documentation>
-      </annotation>
-      <complexType>
-         <sequence>
-            <element ref="overviewelement" minOccurs="1" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="name" type="string" use="required">
-            <annotation>
-               <documentation>
-                  The name of the page.
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="description" type="string">
-            <annotation>
-               <documentation>
-                  A description for the page.
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="overviewelement">
-      <annotation>
-         <documentation>
-            An element that make up a section of the page. Elements can contain Headers, Hyperlinks, Icons and text.
-         </documentation>
-      </annotation>
-      <complexType>
-         <attribute name="icon" type="string">
-            <annotation>
-               <documentation>
-                  An icon to display in the element. The icon should be 72x72 and will appear to the left of the headers, hyperlinks and text
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="resource"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="heading" type="string">
-            <annotation>
-               <documentation>
-                  A short heading for the element (optional)
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="text" type="string">
-            <annotation>
-               <documentation>
-                  The text description for the element
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="hyperlink" type="string">
-            <annotation>
-               <documentation>
-                  A hyperlink associated with the element. The hyperlink would normally execute the hyperlinkaction action
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="hyperlinkaction" type="string">
-            <annotation>
-               <documentation>
-                  The action associated with the hyperlink. This is an action that will be executed when the hyperlink is selected
-               </documentation>
-               <appInfo>
-                  <meta.attribute kind="java"/>
-               </appInfo>
-            </annotation>
-         </attribute>
-         <attribute name="actionparameters" type="string">
-            <annotation>
-               <documentation>
-                  Can be used to pass one or more parameters to the hyperlink action. Parameter must be space separated (optional)
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="since"/>
-      </appInfo>
-      <documentation>
-         1.0.0
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="examples"/>
-      </appInfo>
-      <documentation>
-         &lt;extension
-         id=&quot;org.eclipse.jst.jsf.facesconfig.ui.pageflow.PageflowEditor&quot;
-         name=&quot;%pageflow.editor.intro.name&quot;
-         point=&quot;org.eclipse.jst.jsf.facesconfig.ui.page.overviewPage&quot;&gt;
-      &lt;overviewpage
-            name=&quot;%pageflow.editor.intro.name&quot;
-            description=&quot;%port.editor.intro.description&quot;&gt;
-         &lt;overviewelement
-               icon=&quot;icons/pageflow_72.gif&quot;
-               heading=&quot;%pageflow.editor.intro.heading&quot;
-               text=&quot;%pageflow.editor.intro.description&quot;&gt;
-         &lt;/overviewelement&gt;
-         &lt;overviewelement
-               actionparameters=&quot;Pageflow.designerCheatSheet&quot;
-               icon=&quot;icons/tutorials_72.gif&quot;
-               hyperlinkaction=&quot;org.eclipse.jst.jsf.common.ui.actions.LoadCheatSheetAction&quot;
-               text=&quot;%pageflow.editor.intro.cheatsheets.text&quot;
-               hyperlink=&quot;%pageflow.editor.intro.cheatsheets.link&quot;&gt;
-         &lt;/overviewelement&gt;
-         &lt;overviewelement
-               actionparameters=&quot;http://www.eclipse.org&quot;
-               icon=&quot;icons/overview_72.gif&quot;
-               hyperlinkaction=&quot;org.eclipse.jst.jsf.common.ui.actions.LoadHelpAction&quot;
-               text=&quot;%pageflow.editor.intro.help.text&quot;
-               hyperlink=&quot;%pageflow.editor.intro.help.link&quot;&gt;
-         &lt;/overviewelement&gt;
-         &lt;overviewelement
-               actionparameters=&quot;overview&quot;
-               icon=&quot;icons/gotoeditor_72.gif&quot;
-               hyperlinkaction=&quot;org.eclipse.jst.jsf.common.ui.actions.OpenPageAction&quot;
-               text=&quot;%pageflow.editor.intro.start.text&quot;
-               hyperlink=&quot;%pageflow.editor.intro.start.link&quot;&gt;
-         &lt;/overviewelement&gt;
-      &lt;/overviewpage&gt;
-   &lt;/extension&gt;
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="apiInfo"/>
-      </appInfo>
-      <documentation>
-         
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="implementation"/>
-      </appInfo>
-      <documentation>
-         
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="copyright"/>
-      </appInfo>
-      <documentation>
-         Copyright (c) 2004, 2006 Sybase, Inc. and others. &lt;br&gt;
- All rights reserved. This program and the accompanying materials &lt;br&gt;
- are made available under the terms of the Eclipse Public License v1.0 &lt;br&gt;
- which accompanies this distribution, and is available at &lt;br&gt;
- http://www.eclipse.org/legal/epl-v10.html &lt;br&gt;
- 
-  Contributors: &lt;br&gt;
-      Sybase, Inc. - initial API and implementation &lt;br&gt;
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/CommonResources.properties b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/CommonResources.properties
deleted file mode 100644
index b9527d1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/CommonResources.properties
+++ /dev/null
@@ -1,113 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-####################################################
-# Generic Strings for UI
-####################################################
-
-pluginName=Web Application Development Common
-button.save=&Save
-button.remove=&Remove
-
-####################################################
-# Resource message for Logging
-####################################################
-
-log.msg={0}
-
-log.ResourceUtils=Missing Resource Bundle "{0}".
-log.CommonPlugin=Web Application Development Common Plugin initialized on eclipse version {0}.
-log.FavoriteConfigurations.save.error=Failed to save {0} favorites. File={1}
-log.FavoriteConfigurations.read.error=Failed to read {0} favorites. File={1}
-log.CommonPlugin.image.error=Image {0} not found.
-
-log.IntroductionSection.action.error = Failed to launch the link {0}
-
-####################################################
-# Resource message for Alerts
-####################################################
-
-alert.msg={0}
-
-####################################################
-# Resource messages for FavoriteSection
-####################################################
-favorites.group.label=Favorite Configurations
-favorites.label=&Name:
-favorites.tooltip=Construct common setting favorites for this page.
-favorites.save.tooltip=Save the current options on this page as the favorites.
-favorites.remove.tooltip=Remove the current favorite.
-favorites.default=default
-
-####################################################
-# Resource messages for Preference Pages
-####################################################
-JMTPreferencePage.Description=Expand the tree to edit Web Application preferences.
-
-LoggingPreferencePage.Log.Level.label=Log Level:
-LoggingPreferencePage.Log.Level.tooltip=Select the logging level to output to the selected source.
-LoggingPreferencePage.Log.Level.debug=Debug
-LoggingPreferencePage.Log.Level.info=Info
-LoggingPreferencePage.Log.Level.warn=Warn
-LoggingPreferencePage.Log.Level.error=Error
-LoggingPreferencePage.Log.Level.fatal=Fatal
-LoggingPreferencePage.Console.Group.label=Console
-LoggingPreferencePage.Console.Logging.label=Enable &Console Logging
-LoggingPreferencePage.Console.Logging.tooltip=Receive log message in the Eclipse Console view.
-LoggingPreferencePage.Eclipse.Group.label=Eclipse
-LoggingPreferencePage.Eclipse.Logging.label=Enable &Eclipse Logging
-LoggingPreferencePage.Eclipse.Logging.tooltip=Receive log message in the Eclipse Error Log view.
-LoggingPreferencePage.File.Group.label=File
-LoggingPreferencePage.File.Logging.label=Enable &File Logging
-LoggingPreferencePage.File.Logging.tooltip=Write log message to an external file.
-LoggingPreferencePage.File.clearing.label=Clear log file on &startup
-LoggingPreferencePage.File.clearing.tooltip=Each time Eclipse starts, clear the log file.
-LoggingPreferencePage.File.path.label=&Log file:
-LoggingPreferencePage.File.path.tooltip=Where should the log file go? Partial paths are \n based from: /workspace/.metadata/.plugins/org.eclipse.jst.jsf.common.ui.internal/.
-LoggingPreferencePage.File.button.label=B&rowse
-LoggingPreferencePage.File.button.tooltip=Select a location and file name for file logging.
-LoggingPreferencePage.File.select.label=Select a log file
-LoggingPreferencePage.File.Rollover.Frequency.label=Rollover Fre&quency:
-LoggingPreferencePage.File.Rollover.Frequency.tooltip=Select the frequency of how often to generate a new log file. \n The original log file is appended with a timestamp.
-LoggingPreferencePage.File.Rollover.Frequency.daily=Daily
-LoggingPreferencePage.File.Rollover.Frequency.weekly=Weekly
-LoggingPreferencePage.File.Rollover.Frequency.monthly=Monthly
-
-####################################################
-# Resource messages for BrowserWindow
-####################################################
-BrowserWindow.back.tooltip=Navigate back in the browser
-BrowserWindow.forward.tooltip=Navigate forward in the browser
-BrowserWindow.stop.tooltip=Stop browser navigation
-BrowserWindow.refresh.tooltip=Refresh the browser
-BrowserWindow.reload.tooltip=Reload the browser
-
-####################################################
-# Resource messages for Commmon DialogField
-####################################################
-DialogField.JavaClassWizard.NewClass=New Java Class
-DialogField.ClassButton.SelectType=Select Type
-DialogField.Browse=Browse...
-DialogField.ResourceButton.SelectFile=Select File
-
-####################################################
-# Resource messages for Commmon Dialog
-####################################################
-Dialog.ResourceOnClasspathDialog.StatusMessage=Select a properties file
-Dialog.CommonResourceDialog.StatusMessage0=Select
-Dialog.TreeViewerSelectionDialog.DefaultTitle=Select a File
-
-Wizards.NewPage.Error.InvalidProject=Invalid Web project.
-Error.FileFilter.title=File selection
-Error.ImgFileFilter.error=File selection error:
-Error.ProjectFileDialogContentProvider=Project file dialog error: {0}
-Error.RefreshingLocal=Refreshing local
-
-Service.NoResourceError=Unable to determine Service Model file.
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/IFileFolderConstants.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/IFileFolderConstants.java
deleted file mode 100644
index e74e90a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/IFileFolderConstants.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui;
-
-/**
- * @author mengbo
- * @version 1.5
- */
-public interface IFileFolderConstants {
-
-	/**
-	 * the dot character
-	 */
-	public static final String DOT = "."; //$NON-NLS-1$
-
-	/**
-	 * the path separator
-	 */
-	public static final String PATH_SEPARATOR = "/"; //$NON-NLS-1$
-
-	/** file extensions */
-	/**
-	 * class file extension
-	 */
-	public static final String EXT_CLASS = "class"; //$NON-NLS-1$
-
-	/**
-	 * jar file extension
-	 */
-	public static final String EXT_JAR = "jar"; //$NON-NLS-1$
-
-	/**
-	 * java file extension
-	 */
-	public static final String EXT_JAVA = "java"; //$NON-NLS-1$
-
-
-	/**
-	 * jsp file extension
-	 */
-	public static final String EXT_JSP = "jsp"; //$NON-NLS-1$
-
-	/**
-	 * properties file extension
-	 */
-	public static final String EXT_PROPERTIES = "properties"; //$NON-NLS-1$
-
-	/**
-	 * taglib file extension
-	 */
-	public static final String EXT_TAGLIB = "tld"; //$NON-NLS-1$
-
-	/**
-	 * standard web.xml file name
-	 */
-	public static final String FILE_WEB_XML = "web.xml"; //$NON-NLS-1$
-
-	/** folders */
-
-	/**
-	 * classes folder name
-	 */
-	public static final String FOLDER_CLASS = "classes"; //$NON-NLS-1$
-
-	/**
-	 * icons folder name
-	 */
-	public static final String FOLDER_ICONS = "icons"; //$NON-NLS-1$
-
-	/**
-	 * the meta-inf folder name
-	 */
-	public static final String FOLDER_METAINF = "META-INF"; //$NON-NLS-1$
-
-	/**
-	 * the src folder name
-	 */
-	public static final String FOLDER_SOURCE = "src"; //$NON-NLS-1$
-
-	/**
-	 * the web-inf folder name
-	 */
-	public static final String FOLDER_WEBINF = "WEB-INF"; //$NON-NLS-1$
-
-	/** the webroot folder depth relative to the project */
-	public static final int WEBROOT_FOLDER_DEPTH = 2;
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/JSFUICommonPlugin.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/JSFUICommonPlugin.java
deleted file mode 100644
index b4a1f00..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/JSFUICommonPlugin.java
+++ /dev/null
@@ -1,418 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.util.MissingResourceException;
-import java.util.Properties;
-import java.util.ResourceBundle;
-
-import org.eclipse.core.resources.ResourcesPlugin;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Platform;
-import org.eclipse.core.runtime.Status;
-import org.eclipse.jface.preference.IPreferenceStore;
-import org.eclipse.jface.resource.ImageDescriptor;
-import org.eclipse.jface.resource.ImageRegistry;
-import org.eclipse.jst.jsf.common.ui.internal.guiutils.Alerts;
-import org.eclipse.jst.jsf.common.ui.internal.logging.Logger;
-import org.eclipse.swt.graphics.Image;
-import org.eclipse.ui.plugin.AbstractUIPlugin;
-import org.osgi.framework.BundleContext;
-import org.osgi.framework.Version;
-
-/**
- * The main plugin class to be used in the desktop.
- */
-public class JSFUICommonPlugin extends AbstractUIPlugin {
-	// Properties contains general properties and defaults to preferences.
-	private static final String PROPERTIES = "default.properties"; //$NON-NLS-1$
-	// preferences will
-	// contain this string
-	// in the key.
-
-	private static final String P_CONSOLE_LOGGING = "console.logging.on"; //$NON-NLS-1$
-
-	private static final String P_CONSOLE_LOG_LEVEL = "console.logging.max.level"; //$NON-NLS-1$
-
-	private static final String P_ECLIPSE_LOGGING = "eclipse.logging.on"; //$NON-NLS-1$
-
-	private static final String P_ECLIPSE_LOG_LEVEL = "eclipse.logging.max.level"; //$NON-NLS-1$
-
-	private static final String P_FILE_LOGGING = "file.logging.on"; //$NON-NLS-1$
-
-	private static final String P_FILE_LOG_LEVEL = "file.logging.max.level"; //$NON-NLS-1$
-
-	private static final String P_FILE_PATH = "file.logging.path"; //$NON-NLS-1$
-
-	private static final String P_FILE_CLEAR = "file.logging.startup.clear"; //$NON-NLS-1$
-
-	private static final String P_FILE_ROLLOVER_FREQUENCY = "file.logging.rollover.frequency"; //$NON-NLS-1$
-
-	private static final int DEBUG_LEVEL = 0;
-
-	private static final int INFO_LEVEL = 1;
-
-	private static final int WARN_LEVEL = 2;
-
-	private static final int ERROR_LEVEL = 3;
-
-	private static final int FATAL_LEVEL = 4;
-	
-	// What version of the platform are we on.
-	private static boolean TWO_DOT_ONE;
-
-	private static boolean THREE_DOT;
-
-	private static String _version;
-
-	// The shared instance.
-	private static JSFUICommonPlugin _plugin;
-
-	private Logger _log;
-
-	private ResourceBundle _resourceBundle;
-
-	private Properties _properties;
-
-	private URL _pluginBase;
-
-	private static Alerts _alerts;
-
-	/**
-	 * The constructor.
-	 */
-	public JSFUICommonPlugin() {
-		super();
-		_plugin = this;
-		versionCheck();
-	}
-
-	private void versionCheck() {
-		String version = (String) ResourcesPlugin.getPlugin().getBundle()
-				.getHeaders().get(org.osgi.framework.Constants.BUNDLE_VERSION);
-		Version identifier = new Version(version);
-
-		TWO_DOT_ONE = ((identifier.getMajor() == 2) && (identifier
-				.getMinor() == 1));
-		THREE_DOT = (identifier.getMajor() == 3);
-		_version = identifier.toString();
-	}
-
-	/**
-	 * This method is called upon plug-in activation
-	 */
-	public void start(BundleContext context) throws Exception {
-		super.start(context);
-
-		// This plugin is for 3.0 only, do a version check.
-		if (isThreeDot() == false) {
-			throw new CoreException(new Status(IStatus.ERROR, getBundle()
-					.getSymbolicName(), IStatus.OK,
-					"Requires eclipse version 3.x", null)); //$NON-NLS-1$
-		}
-
-		try {
-			// get resource bundle.
-			_resourceBundle = ResourceBundle
-					.getBundle("org.eclipse.jst.jsf.common.ui.CommonResources"); //$NON-NLS-1$
-			_alerts = new Alerts(this, _resourceBundle);
-
-			// get properties.
-			_properties = new Properties();
-			InputStream input = null;
-			_pluginBase = getBundle().getEntry("/"); //$NON-NLS-1$
-			try {
-				input = (new URL(_pluginBase, PROPERTIES)).openStream();
-				_properties.load(input);
-			} finally {
-				try {
-					input.close();
-				} catch (IOException ee)// NOPMD
-				{
-					// nothing to do when IOException throwed in closing files.
-				}
-			}
-
-			// set up logging for this plugin and everthing under it.
-			_log = new Logger(this.getBundle(), _resourceBundle);
-
-			// NOTE: add in any other plugin code statup HERE!!!!
-
-			// log.CommonPlugin=Web Application Development Common Plugin
-			// initialized on eclipse version {0}.
-
-			// log.info("log.CommonPlugin", version);
-
-		} catch (Exception ee) {
-			// only log if the logger was configured correctly.
-			if (_log != null) {
-				_log
-						.error(
-								"log.msg", //$NON-NLS-1$
-								"Problems starting plug-in Web Application Development Common.", //$NON-NLS-1$
-								ee);
-			}
-
-			throw new CoreException(
-					new Status(
-							IStatus.ERROR,
-							getBundle().getSymbolicName(),
-							IStatus.OK,
-							"Problems starting plug-in Web Application Development Common", //$NON-NLS-1$
-							ee));
-		}
-	}
-
-	/**
-	 * Returns the shared instance.
-	 * @return the plugin instance
-	 */
-	public static JSFUICommonPlugin getDefault() {
-		return _plugin;
-	}
-
-	/**
-	 * get the alerts objects associated with this plugin for alerting the user.
-	 * 
-	 * @return the alerts object
-	 */
-	public static Alerts getAlerts() {
-		return _alerts;
-	}
-
-	/**
-	 * Returns a logger for the new class using this plugin for reference.
-	 * @param theClass 
-	 * @return the logger
-	 */
-    // TODO: theClass is never used!!
-	public static Logger getLogger(Class theClass) {
-		return getDefault().getRootLogger();
-	}
-
-	/**
-	 * Returns the plugin's root logger
-	 * @return the root logger
-	 */
-	public Logger getRootLogger() {
-		return _log;
-	}
-
-	/**
-	 * Returns this plugin's unique identifier
-	 * 
-	 * @return this plugin's unique identifier
-	 * 
-	 */
-	public static String getPluginId() {
-		return getDefault().getBundle().getSymbolicName();
-	}
-
-	/**
-	 * Returns the plugin's resource bundle,
-	 * @return the resource bundle
-	 */
-	public ResourceBundle getResourceBundle() {
-		return _resourceBundle;
-	}
-
-	/**
-	 * Returns the string from the plugin's resource bundle, or 'key' if not
-	 * found.
-	 * @param key 
-	 * @return the resource string
-	 */
-	public static String getResourceString(String key) {
-		ResourceBundle bundle = JSFUICommonPlugin.getDefault().getResourceBundle();
-		try {
-			return (bundle != null) ? bundle.getString(key) : key;
-		} catch (MissingResourceException e) {
-			return key;
-		}
-	}
-
-	/**
-	 * Returns the plugin's descriptor's resource bundle,
-	 * @return the bundle
-	 */
-	public ResourceBundle getPluginDecriptorBundle() {
-		return Platform.getResourceBundle(getDefault().getBundle());
-	}
-
-	/**
-	 * Returns the plugin's default properties. These are normally used for
-	 * default preferences.
-	 * @return the properties
-	 */
-	public Properties getProperties() {
-		return _properties;
-	}
-
-	/**
-	 * Returns a shared image for the given name
-	 * <p>
-	 * Note: Images returned from this method will be automitically disposed of
-	 * when this plug-in shuts down. Callers must not dispose of these images
-	 * themselves.
-	 * </p>
-	 * 
-	 * @param name
-	 *            the image name found in /icons (with extension)
-	 * @return the image, null on error or not found.
-	 */
-	public Image getImage(String name) {
-		if (name == null) {
-			return null;
-		}
-
-		ImageRegistry images = getImageRegistry();
-		Image image = images.get(name);
-		if (image == null) {
-			try {
-				ImageDescriptor id = ImageDescriptor.createFromURL(new URL(
-						_pluginBase, "icons/" + name)); //$NON-NLS-1$
-				images.put(name, id);
-
-				image = images.get(name);
-			} catch (MalformedURLException ee) {
-				// log.CommonPlugin.image.error=Image {0} not found.
-				_log.error("log.msg", "log.CommonPlugin.image.error", name, ee); //$NON-NLS-1$ //$NON-NLS-2$
-			}
-		}
-		return image;
-	}
-
-	/**
-	 * Returns a shared ImageDescriptor for the given name
-	 * <p>
-	 * Note: ImageDescriptor returned from this method will be automitically
-	 * disposed of when this plug-in shuts down. Callers must not dispose of
-	 * these ImageDescriptor themselves.
-	 * </p>
-	 * 
-	 * @param name
-	 *            the ImageDescriptor name found in /icons (with extension)
-	 * @return the ImageDescriptor, null on error or not found.
-	 */
-	public ImageDescriptor getImageDescriptor(String name) {
-		if (name == null) {
-			return null;
-		}
-
-		ImageRegistry images = getImageRegistry();
-		ImageDescriptor id = images.getDescriptor(name);
-		if (id == null) {
-			try {
-				id = ImageDescriptor.createFromURL(new URL(_pluginBase,
-						"icons/" + name)); //$NON-NLS-1$
-				images.put(name, id);
-			} catch (MalformedURLException ee) {
-				// log.CommonPlugin.image.error=Image {0} not found.
-				_log.error("log.msg", "log.CommonPlugin.image.error", name, ee); //$NON-NLS-1$ //$NON-NLS-2$
-			}
-		}
-		return id;
-	}
-
-	/**
-	 * Is this eclipse version 2.1
-	 * 
-	 * @return true if version is 2.1
-	 */
-	public static boolean isTwoDotOne() {
-		return TWO_DOT_ONE;
-	}
-
-	/**
-	 * Is this eclipse version 3.x
-	 * 
-	 * @return true if version is 3.x
-	 */
-	public static boolean isThreeDot() {
-		return THREE_DOT;
-	}
-
-	/**
-	 * get the eclipse version
-	 * 
-	 * @return version string.
-	 */
-	public static String getVersion() {
-		return _version;
-	}
-
-
-
-	/**
-	 * Initializes the preference controls to the default values. These values
-	 * are used the first time the preference page is displayed or when the user
-	 * presses the Defaults button in the preferences page.
-	 */
-	protected void initializeDefaultPreferences(IPreferenceStore store) {
-		// NOTE: no logging can happen here since we haven't initialized logging
-		// yet because it
-		// depends on preferences!!!!
-
-		store.setDefault(P_CONSOLE_LOGGING, _properties.getProperty(
-				P_CONSOLE_LOGGING, Boolean.TRUE.toString()));
-		store.setDefault(P_CONSOLE_LOG_LEVEL, strToIntLogLevel(_properties
-				.getProperty(P_CONSOLE_LOG_LEVEL, "ERROR"))); //$NON-NLS-1$
-
-		store.setDefault(P_ECLIPSE_LOGGING, _properties.getProperty(
-				P_ECLIPSE_LOGGING, Boolean.TRUE.toString()));
-		store.setDefault(P_ECLIPSE_LOG_LEVEL, strToIntLogLevel(_properties
-				.getProperty(P_ECLIPSE_LOG_LEVEL, "ERROR"))); //$NON-NLS-1$
-
-		store.setDefault(P_FILE_LOGGING, _properties.getProperty(
-				P_FILE_LOGGING, Boolean.FALSE.toString()));
-		store.setDefault(P_FILE_LOG_LEVEL, strToIntLogLevel(_properties
-				.getProperty(P_FILE_LOG_LEVEL, "ERROR"))); //$NON-NLS-1$
-		store.setDefault(P_FILE_PATH, _properties.getProperty(P_FILE_PATH, "")); //$NON-NLS-1$
-		store.setDefault(P_FILE_CLEAR, _properties.getProperty(P_FILE_CLEAR,
-				Boolean.TRUE.toString()));
-		store.setDefault(P_FILE_ROLLOVER_FREQUENCY, _properties.getProperty(
-				P_FILE_ROLLOVER_FREQUENCY, "DAILY")); //$NON-NLS-1$
-	}
-
-	/**
-	 * Converts the log level from string to int. The level defaults to
-	 * ERROR_LEVEL.
-	 * 
-	 * @param str
-	 *            String representation of log level
-	 * @return integer representation of log level
-	 */
-	private int strToIntLogLevel(String str) {
-		if (str == null) {
-			return ERROR_LEVEL;
-		}
-		if (str.equalsIgnoreCase("DEBUG")) { //$NON-NLS-1$
-			return DEBUG_LEVEL;
-		}
-		if (str.equalsIgnoreCase("INFO")) { //$NON-NLS-1$
-			return INFO_LEVEL;
-		}
-		if (str.equalsIgnoreCase("WARN")) { //$NON-NLS-1$
-			return WARN_LEVEL;
-		}
-		if (str.equalsIgnoreCase("FATAL")) { //$NON-NLS-1$
-			return FATAL_LEVEL;
-		}
-		return ERROR_LEVEL;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/actions/IOpenPage.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/actions/IOpenPage.java
deleted file mode 100644
index 8456083..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/actions/IOpenPage.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.actions;
-
-/**
- * Editors should implement this if they can handle reseting to a page based on
- * the class defined for that page.
- * 
- * @author collinsc,jchoi
- */
-public interface IOpenPage {
-	/**
-	 * Sets the currently active page from the id of the page.
-	 * 
-	 * @param pageID
-	 */
-	public void setActiveEditorPage(String pageID);
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/actions/LoadCheatSheetAction.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/actions/LoadCheatSheetAction.java
deleted file mode 100644
index de7406f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/actions/LoadCheatSheetAction.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.actions;
-
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IConfigurationElement;
-import org.eclipse.core.runtime.IExecutableExtension;
-import org.eclipse.jface.action.Action;
-import org.eclipse.ui.cheatsheets.OpenCheatSheetAction;
-
-/**
- * This class is used to open the cheat sheet based on the configuration
- * parameter.
- * 
- * @author mengbo
- */
-public class LoadCheatSheetAction extends Action implements
-		IExecutableExtension {
-	private String _cheatSheetName = null;
-
-	/**
-	 * 
-	 */
-	public LoadCheatSheetAction() {
-		super();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jface.action.IAction#run()
-	 */
-	public void run() {
-		if (_cheatSheetName != null) {
-			OpenCheatSheetAction action = new OpenCheatSheetAction(
-					_cheatSheetName);
-			action.run();
-		}
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.core.runtime.IExecutableExtension#setInitializationData(org.eclipse.core.runtime.IConfigurationElement,
-	 *      java.lang.String, java.lang.Object)
-	 */
-	public void setInitializationData(IConfigurationElement config,
-			String propertyName, Object data) throws CoreException {
-		_cheatSheetName = config.getAttribute("actionparameters"); //$NON-NLS-1$
-	}
-
-	/**
-	 * set the cheatSheetName name to open.
-	 * 
-	 * @param cheatSheetName
-	 */
-	public void setCheatSheetName(String cheatSheetName) {
-		_cheatSheetName = cheatSheetName;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/actions/LoadHelpAction.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/actions/LoadHelpAction.java
deleted file mode 100644
index 18b927d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/actions/LoadHelpAction.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.actions;
-
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IConfigurationElement;
-import org.eclipse.core.runtime.IExecutableExtension;
-import org.eclipse.help.HelpSystem;
-import org.eclipse.help.IContext;
-import org.eclipse.help.IHelpResource;
-import org.eclipse.jface.action.Action;
-import org.eclipse.ui.PlatformUI;
-
-/**
- * This class is used to open the help page for a configuration param.
- * 
- * @author mengbo
- */
-public class LoadHelpAction extends Action implements IExecutableExtension {
-	private String _helpContextId = null;
-
-	/**
-	 * 
-	 */
-	public LoadHelpAction() {
-		super();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jface.action.IAction#run()
-	 */
-	public void run() {
-		IContext context = HelpSystem.getContext(_helpContextId);
-		if (context != null) {
-			IHelpResource[] topics = context.getRelatedTopics();
-			if (topics != null && topics.length == 1) {
-				PlatformUI.getWorkbench().getHelpSystem().displayHelpResource(
-						topics[0].getHref());
-			} else {
-				PlatformUI.getWorkbench().getHelpSystem().displayHelp(
-						_helpContextId);
-			}
-		}
-
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.core.runtime.IExecutableExtension#setInitializationData(org.eclipse.core.runtime.IConfigurationElement,
-	 *      java.lang.String, java.lang.Object)
-	 */
-	public void setInitializationData(IConfigurationElement config,
-			String propertyName, Object data) throws CoreException {
-		_helpContextId = config.getAttribute("actionparameters"); //$NON-NLS-1$
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/actions/OpenPageAction.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/actions/OpenPageAction.java
deleted file mode 100644
index 252e44c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/actions/OpenPageAction.java
+++ /dev/null
@@ -1,118 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.actions;
-
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IConfigurationElement;
-import org.eclipse.core.runtime.IExecutableExtension;
-import org.eclipse.jface.action.Action;
-import org.eclipse.jface.viewers.ISelection;
-import org.eclipse.jface.viewers.ISelectionProvider;
-import org.eclipse.ui.IEditorPart;
-import org.eclipse.ui.IWorkbenchPage;
-import org.eclipse.ui.IWorkbenchWindow;
-import org.eclipse.ui.PlatformUI;
-import org.eclipse.ui.forms.editor.FormEditor;
-
-/**
- * This class is used to open a page in the editor based on the configuration
- * parameter.
- * 
- * @author collinsc,jchoi
- */
-public class OpenPageAction extends Action implements IExecutableExtension {
-	private String pageID = null;
-
-	private ISelection selection;
-
-	/**
-	 * 
-	 */
-	public OpenPageAction() {
-		super();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jface.action.IAction#run()
-	 */
-	public void run() {
-		if (pageID != null) {
-			// get the active editor
-			IEditorPart editor = getActiveEditor();
-			IOpenPage openPage = (IOpenPage)editor.getAdapter(IOpenPage.class);
-			if(openPage != null){
-				openPage.setActiveEditorPage(pageID);
-				if (selection != null && editor instanceof FormEditor) {
-					IEditorPart activePage = ((FormEditor) editor)
-							.getActiveEditor();
-					if (activePage instanceof ISelectionProvider) {
-						((ISelectionProvider) activePage)
-								.setSelection(selection);
-					}
-				}
-			}
-		}
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.core.runtime.IExecutableExtension#setInitializationData(org.eclipse.core.runtime.IConfigurationElement,
-	 *      java.lang.String, java.lang.Object)
-	 */
-	public void setInitializationData(IConfigurationElement config,
-			String propertyName, Object data) throws CoreException {
-		pageID = config.getAttribute("actionparameters"); //$NON-NLS-1$
-	}
-
-	/**
-	 * set the class name to open.
-	 * @param className 
-	 */
-	public void setPageName(String className) {
-		this.pageID = className;
-	}
-
-	/**
-	 * get the current active editor
-	 * 
-	 * @return the active editor part
-	 */
-	public static IEditorPart getActiveEditor() {
-		IEditorPart editor = null;
-		IWorkbenchWindow win = PlatformUI.getWorkbench()
-				.getActiveWorkbenchWindow();
-		if (win != null) {
-			IWorkbenchPage page = win.getActivePage();
-			if (page != null) {
-				editor = page.getActiveEditor();
-			}
-		}
-		return editor;
-	}
-
-	/**
-	 * @return stored selection
-	 */
-	public ISelection getSelection() {
-		return selection;
-	}
-
-	/**
-	 * @param selection
-	 */
-	public void setSelection(ISelection selection) {
-		this.selection = selection;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/AbstractClassButtonDialogField.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/AbstractClassButtonDialogField.java
deleted file mode 100644
index 165846a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/AbstractClassButtonDialogField.java
+++ /dev/null
@@ -1,238 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.ResourceBundle;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.core.JavaCore;
-import org.eclipse.jdt.core.search.IJavaSearchScope;
-import org.eclipse.jdt.ui.IJavaElementSearchConstants;
-import org.eclipse.jface.dialogs.Dialog;
-import org.eclipse.jface.wizard.WizardDialog;
-import org.eclipse.jst.jsf.common.ui.JSFUICommonPlugin;
-import org.eclipse.jst.jsf.common.ui.internal.guiutils.Alerts;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.graphics.Point;
-import org.eclipse.swt.widgets.Shell;
-import org.eclipse.ui.dialogs.SelectionDialog;
-import org.eclipse.ui.forms.events.HyperlinkAdapter;
-import org.eclipse.ui.forms.events.HyperlinkEvent;
-
-/**
- * @author mengbo
- * @version 1.5
- */
-/*package*/ abstract class AbstractClassButtonDialogField extends
-		StringButtonDialogField {
-	private IProject _project;
-
-	private String _superClass;
-
-	private List _interfacesList;
-
-	private IType _type;
-
-	private int _typeFlag = IJavaElementSearchConstants.CONSIDER_ALL_TYPES;
-
-	private boolean _autoOpenResource = true;
-
-	/**
-	 * @param autoOpenResource
-	 */
-	public void setAutoOpenResource(boolean autoOpenResource) {
-		_autoOpenResource = autoOpenResource;
-	}
-
-	/**
-	 * @param project
-	 */
-	public AbstractClassButtonDialogField(IProject project) {
-		super(null);
-		this._project = project;
-
-		setHyperLink(new HyperlinkAdapter() {
-			public void linkActivated(HyperlinkEvent e) {
-				activeLink();
-			}
-		});
-
-		setStringButtonAdapter(new IStringButtonAdapter() {
-			public void changeControlPressed(DialogField field) {
-				browseButtonPressed();
-			}
-		});
-	}
-
-	private void activeLink() {
-		String className = getText();
-		className = trimNonAlphaChars(className);
-		if (className.length() > 0
-				&& JavaUIHelper.doesClassExist(_project, className)) {
-			JavaUIHelper.doOpenClass(_project, className);
-		} else {
-			try {
-				if (_project == null || !_project.hasNature(JavaCore.NATURE_ID)) {
-					ResourceBundle rb = ResourceBundle
-							.getBundle("org.eclipse.jst.jsf.common.ui.internal.dialogfield.DialogFieldResources"); //$NON-NLS-1$
-					Alerts alerts = new Alerts(JSFUICommonPlugin.getDefault(), rb);
-					alerts.error("ClassButtonDialogField.Alert.Title", //$NON-NLS-1$
-							"ClassButtonDialogField.Alert.Msg"); //$NON-NLS-1$
-					return;
-				}
-			} catch (CoreException e) {
-				e.printStackTrace();
-				return;
-			}
-			JavaClassWizard wizard = new JavaClassWizard(_project, className,
-					_superClass, getImplementInterfaces());
-			wizard.setAutoOpenResource(_autoOpenResource);
-			WizardDialog dialog = new WizardDialog(getShell(), wizard);
-			dialog.create();
-
-			setDialogSize(dialog, 400, 500);
-			if (dialog.open() == WizardDialog.OK) {
-				String newValue = wizard.getClassNameWithArgs();
-				if (!newValue.equals(className)) {
-					setText(newValue);
-				}
-			}
-		}
-	}
-
-	/**
-	 * @return the interfaces 
-	 * TODO: the contract seems inconsistent
-	 * as whether to return null or empty list when none
-	 */
-	protected abstract List getImplementInterfaces();
-
-	/**
-	 * @return the java search scope to be used.  Must not be null
-	 */
-	protected abstract IJavaSearchScope getJavaSearchScope();
-
-	private void browseButtonPressed() {
-		Shell shell = getShell();
-		SelectionDialog dialog = JavaUIHelper.openSelectionDialog(shell,
-				getJavaSearchScope(), _typeFlag);
-		dialog.setTitle(JSFUICommonPlugin
-				.getResourceString("DialogField.ClassButton.SelectType"));//$NON-NLS-1$
-
-		if (dialog.open() == SelectionDialog.OK) {
-			String oldClassName = getText();
-			if (dialog.getResult() != null) {
-				_type = (IType) dialog.getResult()[0];
-				String newClassName = _type.getFullyQualifiedName();
-				if (!oldClassName.equals(newClassName)) {
-					setText(newClassName);
-				}
-			}
-		}
-	}
-
-	private void setDialogSize(Dialog dialog, int width, int height) {
-		Point computedSize = dialog.getShell().computeSize(SWT.DEFAULT,
-				SWT.DEFAULT);
-		width = Math.max(computedSize.x, width);
-		height = Math.max(computedSize.y, height);
-		dialog.getShell().setSize(width, height);
-	}
-
-	private String trimNonAlphaChars(String className) {
-		className = className.trim();
-		while (className.length() > 0
-				&& !Character.isLetter(className.charAt(0))) {
-			className = className.substring(1, className.length());
-		}
-		int loc = className.indexOf(":"); //$NON-NLS-1$
-		if (loc != -1 && loc > 0) {
-			className = className.substring(0, loc);
-		} else if (loc == 0) {
-			className = ""; //$NON-NLS-1$
-		}
-		return className;
-	}
-
-	/**
-	 * @return Returns the project.
-	 */
-	public IProject getProject() {
-		return _project;
-	}
-
-	/**
-	 * @param project
-	 *            The project to set.
-	 */
-	public void setProject(IProject project) {
-		this._project = project;
-	}
-
-	/**
-	 * @return Returns the superClassName.
-	 */
-	public String getSuperClassName() {
-		return _superClass;
-	}
-
-	/**
-	 * @param superClassName
-	 *            The superClassName to set.
-	 */
-	public void setSuperClassName(String superClassName) {
-		this._superClass = superClassName;
-	}
-
-	/**
-	 * @return Returns the interfacesList.
-	 */
-	protected List getInterfacesList() {
-		return _interfacesList;
-	}
-
-	/**
-	 * Sets (replaces) the interface list
-	 * TODO: this list can have at most one element
-	 * @param interfaceName
-	 */
-	public void setInterface(String interfaceName) {
-		_interfacesList = new ArrayList();
-		_interfacesList.add(interfaceName);
-	}
-
-	/**
-	 * @return Returns the _type.
-	 */
-	public IType getType() {
-		return _type;
-	}
-
-	/**
-	 * @return Returns the typeFalg.
-	 */
-	public int getTypeFlag() {
-		return _typeFlag;
-	}
-
-	/**
-	 * @param typeFalg
-	 *            The typeFalg to set.
-	 */
-	public void setTypeFlag(int typeFalg) {
-		this._typeFlag = typeFalg;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/ClassButtonDialogField.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/ClassButtonDialogField.java
deleted file mode 100644
index baed42b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/ClassButtonDialogField.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import java.util.List;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.core.JavaCore;
-import org.eclipse.jdt.core.search.IJavaSearchScope;
-import org.eclipse.jdt.core.search.SearchEngine;
-
-/**
- * @author mengbo
- */
-public class ClassButtonDialogField extends AbstractClassButtonDialogField {
-	/**
-	 * @param project
-	 */
-	public ClassButtonDialogField(IProject project) {
-		super(project);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.jsf.common.ui.internal.dialogfield.AbstractClassButtonDialogField#getImplementInterfaces()
-	 */
-	protected List getImplementInterfaces() {
-		return getInterfacesList();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.jsf.common.ui.internal.dialogfield.AbstractClassButtonDialogField#getJavaSearchScope()
-	 */
-	protected IJavaSearchScope getJavaSearchScope() {
-		IJavaSearchScope scope;
-		String superType = getSuperClassName();
-		List interfaceList = getInterfacesList();
-		if (superType == null && interfaceList != null
-				&& interfaceList.size() > 0) {
-			superType = interfaceList.get(0).toString();
-		}
-		if (getSuperClassName() != null && interfaceList != null
-				&& interfaceList.size() > 0) {
-			superType = null;
-		}
-		if (superType == null) {
-			scope = SearchEngine
-					.createJavaSearchScope(new IJavaProject[] { JavaCore
-							.create(getProject()) });
-		} else {
-			scope = JavaUIHelper.findSearchScope(getProject(), superType);
-		}
-		return scope;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/ColorButtonDialogField.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/ColorButtonDialogField.java
deleted file mode 100644
index 8228414..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/ColorButtonDialogField.java
+++ /dev/null
@@ -1,339 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-
-import org.eclipse.jst.jsf.common.ui.internal.utils.StyleCombo;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.DisposeEvent;
-import org.eclipse.swt.events.DisposeListener;
-import org.eclipse.swt.events.FocusAdapter;
-import org.eclipse.swt.events.FocusEvent;
-import org.eclipse.swt.events.SelectionEvent;
-import org.eclipse.swt.events.SelectionListener;
-import org.eclipse.swt.graphics.Color;
-import org.eclipse.swt.graphics.Font;
-import org.eclipse.swt.graphics.GC;
-import org.eclipse.swt.graphics.Image;
-import org.eclipse.swt.graphics.ImageData;
-import org.eclipse.swt.graphics.Point;
-import org.eclipse.swt.graphics.RGB;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.widgets.Button;
-import org.eclipse.swt.widgets.ColorDialog;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.ui.forms.widgets.FormToolkit;
-
-/**
- * This class provides a common color choice DialogFiled.
- * 
- * @author mengbo
- */
-public class ColorButtonDialogField extends StyleComboDialogField {
-	// color selection button
-	private Button _button;
-
-	// the button enable flag
-	private boolean _buttonEnabled;
-
-	// the current color
-	private Color _color;
-
-	// the current color RGB
-	private RGB _colorValue;
-
-	// the combo control
-	private StyleCombo _combo;
-
-	// when no color is set or selected, using the empty image
-	private Image _emptyImage;
-
-	// size of color image
-	private Point _extent;
-
-	// the color image
-	private Image _image;
-    
-    private ColorPalette    _colorPalette;
-
-	/**
-	 * @param flags
-	 * @param colorPalette
-	 */
-	public ColorButtonDialogField(int flags, ColorPalette colorPalette) {
-		super(flags);
-		_buttonEnabled = true;
-        _colorPalette = colorPalette;
-	}
-
-	private void buttonPressed() {
-		ColorDialog colorDialog = new ColorDialog(_button.getShell());
-		colorDialog.setRGB(_colorValue);
-		RGB newColor = colorDialog.open();
-		if (newColor != null && !newColor.equals(_colorValue)) {
-			_colorValue = newColor;
-			setText(ColorPalette.getStringColor(newColor));
-			updateColorImage();
-		}
-	}
-
-	/**
-	 * Compute the size of the image to be displayed.
-	 * 
-	 * @param window -
-	 *            the window used to calculate
-	 * @return <code>Point</code>
-	 */
-	private Point computeImageSize(Control window) {
-		GC gc = new GC(window);
-		Font f = _button.getFont();
-		gc.setFont(f);
-		int height = gc.getFontMetrics().getHeight();
-
-		Point p = new Point(height * 3 - 6, height - 2);
-		gc.dispose();
-		return p;
-	}
-
-	private void disposeResources() {
-		if (_image != null) {
-			_image.dispose();
-			_image = null;
-		}
-		if (_emptyImage != null) {
-			_emptyImage.dispose();
-			_emptyImage = null;
-		}
-		if (_color != null) {
-			_color.dispose();
-			_color = null;
-		}
-
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.jsf.common.ui.internal.dialogfield.DialogField#doFillIntoGrid(org.eclipse.ui.forms.widgets.FormToolkit,
-	 *      org.eclipse.swt.widgets.Composite, int)
-	 */
-	public Control[] doFillIntoGrid(FormToolkit toolkit, Composite parent,
-			int nColumns) {
-		assertEnoughColumns(nColumns);
-
-		Control requiredLabel = getRequiredLabelControl(toolkit, parent);
-		requiredLabel.setLayoutData(gridDataForLabel(1));
-
-		Control label = getLabelControl(toolkit, parent);
-		label.setLayoutData(gridDataForLabel(1));
-
-		StyleCombo combo = getComboControl(toolkit, parent);
-		combo.setLayoutData(gridDataForCombo(nColumns - 3));
-
-		_button = getChangeControl(toolkit, parent);
-		_button.setLayoutData(gridDataForButton(1));
-
-		return new Control[] { requiredLabel, label, combo, _button };
-	}
-
-	/**
-	 * Sets the enable state of the button.
-	 * @param enable 
-	 */
-	public void enableButton(boolean enable) {
-		if (isOkToUse(_button)) {
-			_button.setEnabled(isEnabled() && enable);
-		}
-		_buttonEnabled = enable;
-	}
-
-	/**
-	 * Creates or returns the created buttom widget.
-	 * @param toolkit 
-	 * 
-	 * @param parent
-	 *            The parent composite or <code>null</code> if the widget has
-	 *            already been created.
-	 * @return  the button widget
-	 */
-	public Button getChangeControl(FormToolkit toolkit, Composite parent) {
-		if (_button == null) {
-			assertCompositeNotNull(parent);
-			if (toolkit != null) {
-				_button = toolkit.createButton(parent, "", SWT.PUSH); //$NON-NLS-1$
-			} else {
-				_button = new Button(parent, SWT.PUSH);
-			}
-			_button.setEnabled(isEnabled() && _buttonEnabled);
-
-			_button.addSelectionListener(new SelectionListener() {
-				public void widgetDefaultSelected(SelectionEvent e) {
-					buttonPressed();
-				}
-
-				public void widgetSelected(SelectionEvent e) {
-					buttonPressed();
-				}
-			});
-
-			_button.addDisposeListener(new DisposeListener() {
-				public void widgetDisposed(DisposeEvent event) {
-					disposeResources();
-				}
-			});
-
-			_extent = computeImageSize(parent);
-			_image = new Image(parent.getDisplay(), _extent.x, _extent.y);
-			_emptyImage = new Image(parent.getDisplay(), _extent.x, _extent.y);
-			initEmptyImage(_button);
-			updateColorImage();
-		}
-
-		return _button;
-	}
-
-	private String[] getColorList() {
-		Map map = _colorPalette.getExtendedColorMap();
-		List list = new ArrayList(map.keySet());
-		Collections.sort(list);
-		return (String[]) list.toArray(new String[list.size()]);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.jsf.common.ui.internal.dialogfield.StringDialogField#getTextControl(org.eclipse.ui.forms.widgets.FormToolkit,
-	 *      org.eclipse.swt.widgets.Composite)
-	 */
-	public StyleCombo getComboControl(FormToolkit toolkit, Composite parent) {
-
-		if (_combo == null) {
-			_combo = super.getComboControl(toolkit, parent);
-
-			_combo.addSelectionListener(new SelectionListener() {
-
-				public void widgetDefaultSelected(SelectionEvent e) {
-					updateImageAfterChanged();
-				}
-
-				public void widgetSelected(SelectionEvent e) {
-					updateImageAfterChanged();
-				}
-			});
-			_combo.addFocusListener(new FocusAdapter() {
-				public void focusLost(FocusEvent e) {
-					updateImageAfterChanged();
-				}
-			});
-			_combo.setItems(getColorList());
-		}
-		return _combo;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.jsf.common.ui.internal.dialogfield.DialogField#getNumberOfControls()
-	 */
-	public int getNumberOfControls() {
-		return 4;
-	}
-	private GridData gridDataForButton(int span) {
-		GridData gd = new GridData();
-		gd.horizontalAlignment = GridData.FILL;
-		gd.grabExcessHorizontalSpace = false;
-		gd.horizontalSpan = span;
-		gd.widthHint = LayoutUtil.getButtonWidthHint(_button);
-		gd.heightHint = _combo.computeSize(SWT.DEFAULT, SWT.DEFAULT).y;
-		return gd;
-	}
-
-	private void initEmptyImage(Control parent) {
-		Color transparentColor = parent.getForeground();
-		ImageData imageData = _emptyImage.getImageData();
-		imageData.transparentPixel = 0;
-		GC gc = new GC(_emptyImage);
-		gc.setBackground(transparentColor);
-		gc.fillRectangle(0, 0, _emptyImage.getBounds().width, _emptyImage
-				.getBounds().height);
-	}
-
-	/**
-	 * Set the current color value and update the control.
-	 * 
-	 * @param rgb
-	 *            The new color.
-	 */
-	public void setColorValue(RGB rgb) {
-		_colorValue = rgb;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.jsf.common.ui.internal.dialogfield.ComboDialogField#setTextWithoutUpdate(java.lang.String)
-	 */
-	public void setTextWithoutUpdate(String text) {
-		super.setTextWithoutUpdate(text);
-		updateImageAfterChanged();
-	}
-
-	/**
-	 * Update the image being displayed on the button using the current color
-	 * setting.
-	 */
-	protected void updateColorImage() {
-		if (_button.isDisposed()) {
-			return;
-		}
-
-		if (_colorValue == null) {
-			_button.setImage(_emptyImage);
-			return;
-		}
-
-		Display display = _button.getDisplay();
-		GC gc = new GC(_image);
-		gc.setForeground(display.getSystemColor(SWT.COLOR_BLACK));
-		gc.drawRectangle(0, 0, _extent.x - 1, _extent.y - 1);
-		if (_color != null) {
-			_color.dispose();
-		}
-		_color = new Color(display, _colorValue);
-		gc.setBackground(_color);
-		gc.fillRectangle(1, 1, _extent.x - 2, _extent.y - 2);
-		gc.dispose();
-		_button.setImage(_image);
-	}
-
-	/*
-	 * @see DialogField#updateEnableState
-	 */
-	protected void updateEnableState() {
-		super.updateEnableState();
-		if (isOkToUse(_button)) {
-			_button.setEnabled(isEnabled() && _buttonEnabled);
-		}
-	}
-
-	private void updateImageAfterChanged() {
-		String newColor = getText().trim();
-		setColorValue(_colorPalette.getExtendedColorRGB(newColor));
-		updateColorImage();
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/ColorPalette.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/ColorPalette.java
deleted file mode 100644
index 454a4c0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/ColorPalette.java
+++ /dev/null
@@ -1,125 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Set;
-
-import org.eclipse.swt.graphics.Color;
-import org.eclipse.swt.graphics.RGB;
-
-/**
- * Defines a two sets: one of basic and one of extended colors.  Clients extending
- * this class must provide the two maps
- * 
- * @author cbateman
- *
- */
-public abstract class ColorPalette 
-{
-    /**
-     * @param cssText
-     * @return the basic color matching the cssText key or null if color doesn't exist
-     */
-    public final Color getBasicColor(String cssText) {
-        return (Color) getBasicColorMap().get(cssText.toLowerCase());
-    }
-
-    /**
-     * @param cssText
-     * @return the extended color matching the cssText key or null if color doesn't exist
-     */
-    public final Color getExtendedColor(String cssText) {
-        Set keys = getExtendedColorMap().keySet();
-        for (Iterator iterator = keys.iterator(); iterator.hasNext();) {
-            String key = (String) iterator.next();
-            if (key.equalsIgnoreCase(cssText)) {
-                return (Color) getExtendedColorMap().get(key);
-            }
-        }
-        return null;
-    }
-
-    /**
-     * @return the map of basic colors where the key is the color name (a string)
-     * and the value is an RGB object
-     */
-    public abstract Map getBasicColorMap();
-
-    /**
-     * @return the map of extended colors where the key is the color name (a string)
-     * and the value is an Color object
-     */
-    public abstract Map getExtendedColorMap();
-
-    /**
-     * @param textColor
-     * @return same as getExtendedColor but returns value as an RGB object
-     */
-    public final RGB getExtendedColorRGB(String textColor) {
-        if (textColor == null || textColor.length() == 0) {
-            return null;
-        }
-
-        Color color = getExtendedColor(textColor);
-        if (color != null) {
-            return color.getRGB();
-        }
-
-        if (textColor.charAt(0) == '#' && textColor.length() == 4) {
-            char[] rgbChars = textColor.toCharArray();
-            char[] fullChars = { rgbChars[0], rgbChars[1], rgbChars[1],
-                    rgbChars[2], rgbChars[2], rgbChars[3], rgbChars[3] };
-
-            textColor = String.valueOf(fullChars);
-        }
-
-        if (textColor.charAt(0) == '#' && textColor.length() == 7) {
-            try {
-                int intColor = Integer.decode(textColor).intValue();
-
-                if (intColor > 0xFFFFFF || intColor < 0) {
-                    return null;
-                }
-                int r = intColor >> 16;
-                int g = (intColor >> 8) & 0xFF;
-                int b = intColor & 0xFF;
-                return new RGB(r, g, b);
-
-            } catch (NumberFormatException e) {
-                return null;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * @param rgb
-     * @return the hex string for equivalent of the rgb color
-     */
-    public static String getStringColor(RGB rgb) {
-        if (rgb == null) {
-            return ""; //$NON-NLS-1$
-        }
-
-        StringBuffer buffer = new StringBuffer("#"); //$NON-NLS-1$
-        int[] intRGBs = new int[] { rgb.red, rgb.green, rgb.blue };
-        for (int i = 0; i < 3; i++) {
-            if (intRGBs[i] < 16) {
-                buffer.append("0"); //$NON-NLS-1$
-            }
-            buffer.append(Integer.toHexString(intRGBs[i]).toUpperCase());
-        }
-        return buffer.toString();
-    }
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/ComboDialogField.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/ComboDialogField.java
deleted file mode 100644
index 582634e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/ComboDialogField.java
+++ /dev/null
@@ -1,320 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import java.util.Map;
-import java.util.Map.Entry;
-
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.custom.CCombo;
-import org.eclipse.swt.events.FocusAdapter;
-import org.eclipse.swt.events.FocusEvent;
-import org.eclipse.swt.events.ModifyEvent;
-import org.eclipse.swt.events.ModifyListener;
-import org.eclipse.swt.events.SelectionEvent;
-import org.eclipse.swt.events.SelectionListener;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.ui.forms.widgets.FormToolkit;
-
-/**
- * Dialog field containing a label and a combo control.
- * 
- * If the combo control is editable, then when user type in the field, will only
- * fire dialogFieldChanged, without dialogFieldApplied just as text control. But
- * when user change selection using the drop down, will fire both
- * dialogFieldChanged and dialogFieldApplied
- * 
- * @author mengbo
- */
-public class ComboDialogField extends DialogFieldBase implements
-		ISupportTextValue {
-	final static private int WIDTH_HINT = 10;
-
-	private String _text;
-
-	private int _selectionIndex;
-
-	private String[] _items;
-
-	private CCombo _comboControl;
-
-	private ModifyListener _modifyListener;
-
-	private int _flags;
-
-	private boolean _pending = false;
-
-	private Map _entryMap;
-
-	/**
-	 * @param flags
-	 */
-	public ComboDialogField(int flags) {
-		super();
-		_text = ""; //$NON-NLS-1$
-		_items = new String[0];
-		_flags = flags;
-		_selectionIndex = -1;
-	}
-
-	// ------- layout helpers
-
-	/*
-	 * @see DialogField#doFillIntoGrid
-	 */
-	public Control[] doFillIntoGrid(FormToolkit toolkit, Composite parent,
-			int nColumns) {
-		assertEnoughColumns(nColumns);
-
-		Control requiredLabel = getRequiredLabelControl(toolkit, parent);
-		requiredLabel.setLayoutData(gridDataForLabel(1));
-
-		Control label = getLabelControl(toolkit, parent);
-		label.setLayoutData(gridDataForLabel(1));
-
-		CCombo combo = getComboControl(toolkit, parent);
-		combo.setLayoutData(gridDataForCombo(nColumns - 2));
-
-		return new Control[] { requiredLabel, label, combo };
-	}
-
-	/*
-	 * @see DialogField#getNumberOfControls
-	 */
-	public int getNumberOfControls() {
-		return 3;
-	}
-
-	private static GridData gridDataForCombo(int span) {
-		GridData gd = new GridData();
-		gd.horizontalAlignment = GridData.FILL;
-		gd.grabExcessHorizontalSpace = false;
-		gd.horizontalSpan = span;
-		gd.widthHint = WIDTH_HINT;
-		return gd;
-	}
-
-	// ------- focus methods
-
-	/*
-	 * @see DialogField#setFocus
-	 */
-	public boolean setFocus() {
-		if (isOkToUse(_comboControl)) {
-			_comboControl.setFocus();
-		}
-		return true;
-	}
-
-	// ------- ui creation
-
-	/**
-	 * Creates or returns the created combo control.
-	 * @param toolkit 
-	 * 
-	 * @param parent
-	 *            The parent composite or <code>null</code> when the widget
-	 *            has already been created.
-	 * @return the custom combo control
-	 */
-	public CCombo getComboControl(FormToolkit toolkit, Composite parent) {
-		if (_comboControl == null || _comboControl.isDisposed()) {
-			assertCompositeNotNull(parent);
-			_modifyListener = new ModifyListener() {
-				public void modifyText(ModifyEvent e) {
-					doModifyText(e);
-				}
-			};
-			SelectionListener selectionListener = new SelectionListener() {
-				public void widgetSelected(SelectionEvent e) {
-					doSelectionChanged(e);
-				}
-
-				public void widgetDefaultSelected(SelectionEvent e) {
-					handleDefaultSelection(e);
-				}
-			};
-
-			if (toolkit != null) {
-				_comboControl = new CCombo(parent, _flags);
-				toolkit.adapt(_comboControl);
-			} else {
-				_comboControl = new CCombo(parent, _flags | SWT.BORDER);
-				_comboControl.setBackground(Display.getCurrent()
-						.getSystemColor(SWT.COLOR_LIST_BACKGROUND));
-			}
-
-			// moved up due to 1GEUNW2
-			_comboControl.setItems(_items);
-			if (_selectionIndex != -1) {
-				_comboControl.select(_selectionIndex);
-			} else {
-				_comboControl.setText(_text);
-			}
-			_comboControl.setFont(parent.getFont());
-			_comboControl.addModifyListener(_modifyListener);
-			_comboControl.addSelectionListener(selectionListener);
-			_comboControl.addFocusListener(new FocusAdapter() {
-				public void focusLost(FocusEvent e) {
-					doFocusLost(e);
-				}
-			});
-			_comboControl.setEnabled(isEnabled());
-			_comboControl.setToolTipText(getToolTip());
-		}
-		return _comboControl;
-	}
-
-	private void handleDefaultSelection(SelectionEvent e) {
-		// commit value
-		if (_pending) {
-			_pending = false;
-			dialogFieldApplied();
-		}
-	}
-
-	private void doFocusLost(FocusEvent e) {
-		if (_pending) {
-			_pending = false;
-			dialogFieldApplied();
-		}
-	}
-
-	private void doModifyText(ModifyEvent e) {
-		if (isOkToUse(_comboControl)) {
-			_text = getEntryKey(_comboControl.getText());
-			_selectionIndex = _comboControl.getSelectionIndex();
-		}
-		_pending = true;
-		dialogFieldChanged();
-	}
-
-	private void doSelectionChanged(SelectionEvent e) {
-		if (isOkToUse(_comboControl)) {
-			_items = _comboControl.getItems();
-			_text = getEntryKey(_comboControl.getText());
-			_selectionIndex = _comboControl.getSelectionIndex();
-		}
-		_pending = false;
-		dialogFieldChangedAndApplied();
-	}
-
-	// ------ enable / disable management
-
-	/*
-	 * @see DialogField#updateEnableState
-	 */
-	protected void updateEnableState() {
-		super.updateEnableState();
-		if (isOkToUse(_comboControl)) {
-			_comboControl.setEnabled(isEnabled());
-		}
-	}
-
-	// ------ text access
-
-
-	/**
-	 * Sets the combo items. Triggers a dialog-changed event.
-	 * @param items 
-	 */
-	public void setItems(String[] items) {
-		_items = items;
-		if (isOkToUse(_comboControl)) {
-			_comboControl.setItems(items);
-		}
-		_pending = false;
-		// dialogFieldChangedAndApplied();
-	}
-
-	/**
-	 * Gets the text.
-	 */
-	public String getText() {
-		return _text;
-	}
-
-	/**
-	 * Sets the text. Triggers a dialog-changed event.
-	 */
-	public void setText(String text) {
-		setTextWithoutUpdate(text);
-		_pending = false;
-		dialogFieldChangedAndApplied();
-	}
-
-	/**
-	 * Selects an item.
-	 * @param index 
-	 */
-	public void selectItem(int index) {
-		if (isOkToUse(_comboControl)) {
-			_comboControl.select(index);
-		} else {
-			if (index >= 0 && index < _items.length) {
-				_text = getEntryKey(_items[index]);
-				_selectionIndex = index;
-			}
-		}
-		dialogFieldChangedAndApplied();
-	}
-
-	/**
-	 * Sets the text without triggering a dialog-changed event.
-	 */
-	public void setTextWithoutUpdate(String text) {
-		_pending = false;
-		if (text == null) {
-			text = "";//$NON-NLS-1$
-		}
-		_text = text;
-		if (isOkToUse(_comboControl)) {
-			_comboControl.removeModifyListener(_modifyListener);
-			_comboControl.setText(getEntryValue(text));
-			_comboControl.addModifyListener(_modifyListener);
-		}
-	}
-
-	private String getEntryValue(String key) {
-		if (_entryMap == null || !_entryMap.containsKey(key)) {
-			return key;
-		}
-		return _entryMap.get(key).toString();
-	}
-
-	private String getEntryKey(String value) {
-		if (_entryMap == null || !_entryMap.containsValue(value)) {
-			return value;
-		}
-
-		Entry[] entries = (Entry[]) _entryMap.entrySet().toArray(new Entry[0]);
-		for (int i = 0; i < entries.length; i++) {
-			if (entries[i].getValue() == value
-					|| (value != null && value.equals(entries[i].getValue()))) {
-				return entries[i].getKey().toString();
-			}
-		}
-		return value;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.jsf.common.ui.internal.dialogfield.DialogField#handleGrabHorizontal()
-	 */
-	public void handleGrabHorizontal() {
-		LayoutUtil.setGrabHorizontal(_comboControl, true);
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/DialogField.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/DialogField.java
deleted file mode 100644
index 0ff86f7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/DialogField.java
+++ /dev/null
@@ -1,149 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Shell;
-import org.eclipse.ui.forms.events.IHyperlinkListener;
-import org.eclipse.ui.forms.widgets.FormToolkit;
-
-/**
- * @author mengbo
- * @version 1.5
- */
-public interface DialogField {
-	/**
-	 * this method must be called directly after constructor, in this case,
-	 * system will create a hyper link label, and when the hyper link is
-	 * clicked, the corresponding method on the listener will be called. A
-	 * RuntimeException will throw out if this method is called after the label
-	 * has been created.
-	 * 
-	 * @param listener
-	 *            can't be null
-	 */
-	public abstract void setHyperLink(IHyperlinkListener listener);
-
-	/**
-	 * Sets the label of the dialog field.
-	 * @param labeltext 
-	 */
-	public abstract void setLabelText(String labeltext);
-
-	// ------ change listener
-	/**
-	 * Listener that is notified on a field change
-	 * @param listener
-	 */
-	public abstract void setDialogFieldChangeListener(
-			IDialogFieldChangeListener listener);
-
-	/**
-	 * Listener  that is notified on a field apply
-	 * @param listener
-	 */
-	public abstract void setDialogFieldApplyListener(
-			IDialogFieldApplyListener listener);
-
-	// ------- focus management
-	/**
-	 * Tries to set the focus to the dialog field. Returns <code>true</code>
-	 * if the dialog field can take focus. To be re-implemented by dialog field
-	 * implementors.
-	 * @return true if dialog field can take focus
-	 */
-	public abstract boolean setFocus();
-
-	/**
-	 * Creates all controls of the dialog field and fills it to a composite. The
-	 * composite is assumed to have <code>MGridLayout</code> as layout. The
-	 * dialog field will adjust its controls' spans to the number of columns
-	 * given. To be reimplemented by dialog field implementors.
-	 * @param toolkit 
-	 * @param parent 
-	 * @param nColumns 
-	 * @return the controls
-	 */
-	public abstract Control[] doFillIntoGrid(FormToolkit toolkit,
-			Composite parent, int nColumns);
-
-	/**
-	 * Returns the number of columns of the dialog field. To be reimplemented by
-	 * dialog field implementors.
-	 * @return the number of columns
-	 */
-	public abstract int getNumberOfControls();
-
-	// ------- ui creation
-	/**
-	 * @param _formToolkit
-	 * @param parent
-	 * @return the label control
-	 */
-	public abstract Control getLabelControl(FormToolkit _formToolkit,
-			Composite parent);
-
-	// --------- enable / disable management
-	/**
-	 * @param enabled
-	 */
-	public abstract void setEnabled(boolean enabled);
-
-	/**
-	 * Gets the enable state of the dialog field.
-	 * @return true if enabled is set
-	 */
-	public abstract boolean isEnabled();
-
-	/**
-	 * Get attached data by key.
-	 * 
-	 * @param key
-	 * @return the attached data object for key
-	 */
-	public abstract Object getAttachedData(Object key);
-
-	/**
-	 * You can attach any data to the DialogField, and get it using the
-	 * <code>getAttachedData</code> method.
-	 * 
-	 * @param key
-	 * @param value
-	 */
-	public abstract void putAttachedData(Object key, Object value);
-
-	/**
-	 * this method give the DialogField a chance to set the correct column to
-	 * grab horizontal space. In the implementation of this method, should only
-	 * change the GridData of control, should not do anything else.
-	 * 
-	 * The caller is responsible to make sure the controls for the dialog field
-	 * has been created before calling this method.
-	 */
-	public abstract void handleGrabHorizontal();
-
-	/**
-	 * @return true if is required field
-	 */
-	public abstract boolean isRequired();
-
-	/**
-	 * @param toolTip
-	 */
-	public abstract void setToolTip(String toolTip);
-	
-	/**
-	 * @return the field's enclosing shell or null if none
-	 */
-	public Shell getShell();
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/DialogFieldBase.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/DialogFieldBase.java
deleted file mode 100644
index 7d61f49..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/DialogFieldBase.java
+++ /dev/null
@@ -1,559 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import org.eclipse.core.runtime.Assert;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.MouseEvent;
-import org.eclipse.swt.events.MouseTrackAdapter;
-import org.eclipse.swt.graphics.Color;
-import org.eclipse.swt.graphics.FontMetrics;
-import org.eclipse.swt.graphics.GC;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.swt.widgets.Label;
-import org.eclipse.swt.widgets.Shell;
-import org.eclipse.ui.forms.events.IHyperlinkListener;
-import org.eclipse.ui.forms.widgets.FormToolkit;
-import org.eclipse.ui.forms.widgets.Hyperlink;
-
-/**
- * Base class of all Dialog fields. Dialog fields manage controls together with
- * the model, independed from the creation time of the widgets. - support for
- * automated layouting. - enable / disable, set focus a concept of the base
- * class. DialogField have a label.
- * 
- * DialogField may be used in two different context:
- * <ol>
- * <li> In side dialog. In this case, whenever there is anything change in the
- * dialog field, such as user type anything, the dialog should listen to the
- * dialogFieldChanged() events and do things like validation. When user press
- * the "OK" button, dialog should call getXXX to get the value from the dialog
- * field and apply them.
- * <li> In side form based editor or properties view. In this case, whenever
- * there is anything change in the dialog field, such as user type anything, the
- * editor/view should listen to the dialogFieldChanged() events and do things
- * like validation. When user press "Enter" or move the focus out of the control
- * (finish editing), the dialog field will fire out dialogFieldApplied() events,
- * and the editor/view should listen to this event and apply the value to the
- * underlying model.
- * </ol>
- * 
- * The basic idea of the DialogField framework is comming from
- * <code>org.eclipse.jface.preference.FieldEditor</code> and
- * <code>org.eclipse.jdt.internal.ui.wizards.dialogfields.DialogField</code>
- * 
- * @author mengbo
- */
-public class DialogFieldBase implements DialogField {
-	private Label _label;
-
-	private Label _requiredLabel;
-
-	private String _labelText;
-
-	private IDialogFieldChangeListener _dialogFieldChangeListener;
-
-	private IDialogFieldApplyListener _dialogFieldApplyListener;
-
-	private boolean _enabled;
-
-	private FontMetrics _fontMetrics;
-
-	private IHyperlinkListener _listener;
-
-	private Hyperlink _hyperlink;
-
-	private Map _attachedData;
-
-	private boolean _isRequired;
-
-	private String toolTip;
-
-	/**
-	 * default constructor
-	 */
-	public DialogFieldBase() {
-		_enabled = true;
-		_label = null;
-		_requiredLabel = null;
-		_hyperlink = null;
-		_labelText = ""; //$NON-NLS-1$
-	}
-
-	/**
-	 * this method must be called directly after constructor, in this case,
-	 * system will create a hyper link label, and when the hyper link is
-	 * clicked, the corresponding method on the listene will be called. A
-	 * RuntimeException will throw out if this method is called after the label
-	 * has been created.
-	 * 
-	 * @param listener
-	 *            can't be null
-	 */
-	public void setHyperLink(IHyperlinkListener listener) {
-		if (_label != null) {
-			throw new RuntimeException(
-					"The Label instance does not support the listener"); //$NON-NLS-1$
-		}
-        this._listener = listener;
-	}
-
-	/**
-	 * Sets the label of the dialog field.
-	 */
-	public void setLabelText(String labeltext) {
-		_labelText = labeltext == null ? "" : labeltext; //$NON-NLS-1$
-		// if (_isRequired)
-		// {
-		// _labelText = "* " + _labelText;
-		// }
-		// else
-		// {
-		// _labelText = " " + _labelText;
-		// }
-		if (_label != null && !_label.isDisposed()) {
-			_label.setText(_labelText);
-		} else if (_hyperlink != null && !_hyperlink.isDisposed()) {
-			_hyperlink.setText(_labelText);
-		}
-	}
-
-	/**
-	 * @return return the enclosing Shell or null if one cannot be determined
-	 */
-	public Shell getShell() {
-		if (_label != null && !_label.isDisposed()) {
-			return _label.getShell();
-		} else if (_hyperlink != null && !_hyperlink.isDisposed()) {
-			return _hyperlink.getShell();
-		}
-		return null;
-	}
-
-	// ------ change listener
-
-	/**
-	 * Defines the listener for this dialog field.
-	 */
-	public final void setDialogFieldChangeListener(
-			IDialogFieldChangeListener listener) {
-		_dialogFieldChangeListener = listener;
-	}
-
-	public final void setDialogFieldApplyListener(
-			IDialogFieldApplyListener listener) {
-		_dialogFieldApplyListener = listener;
-	}
-
-	/**
-	 * fire both dialogFieldChanged and dialogFieldApplied events.
-	 */
-	public void dialogFieldChangedAndApplied() {
-		if (_dialogFieldChangeListener != null) {
-			_dialogFieldChangeListener.dialogFieldChanged(this);
-		}
-		if (_dialogFieldApplyListener != null) {
-			_dialogFieldApplyListener.dialogFieldApplied(this);
-		}
-	}
-
-	/**
-	 * fire dialogFieldChanged event.
-	 * 
-	 */
-	public void dialogFieldChanged() {
-		if (_dialogFieldChangeListener != null) {
-			_dialogFieldChangeListener.dialogFieldChanged(this);
-		}
-	}
-
-	/**
-	 * fire dialogFieldApplied event.
-	 * 
-	 */
-	public void dialogFieldApplied() {
-		if (_dialogFieldApplyListener != null) {
-			_dialogFieldApplyListener.dialogFieldApplied(this);
-		}
-	}
-
-	// ------- focus management
-
-
-	public boolean setFocus() {
-		return false;
-	}
-
-	//
-	// /**
-	// * Posts <code>setFocus</code> to the display event queue.
-	// */
-	// public void postSetFocusOnDialogField(Display display)
-	// {
-	// if (display != null)
-	// {
-	// display.asyncExec(new Runnable()
-	// {
-	// public void run()
-	// {
-	// setFocus();
-	// }
-	// }
-	// );
-	// }
-	// }
-
-	// ------- layout helpers
-
-	public Control[] doFillIntoGrid(FormToolkit toolkit, Composite parent,
-			int nColumns) {
-		assertEnoughColumns(nColumns);
-
-		Control label = getLabelControl(toolkit, parent);
-		label.setLayoutData(gridDataForLabel(nColumns));
-
-		return new Control[] { label };
-	}
-
-	/**
-	 * Initializes the computation of horizontal and vertical dialog units based
-	 * on the size of current font.
-	 * <p>
-	 * This method must be called before any of the dialog unit based conversion
-	 * methods are called.
-	 * </p>
-	 * 
-	 * @param control
-	 *            a control from which to obtain the current font
-	 * @return the font metrics for control
-	 */
-	protected FontMetrics getDialogUnits(Control control) {
-		if (_fontMetrics == null) {
-			// Compute and store a font metric
-			GC gc = new GC(control);
-			gc.setFont(control.getFont());
-			_fontMetrics = gc.getFontMetrics();
-			gc.dispose();
-		}
-		return _fontMetrics;
-	}
-
-	/**
-	 * Returns the number of columns of the dialog field. To be reimplemented by
-	 * dialog field implementors.
-	 */
-	public int getNumberOfControls() {
-		return 1;
-	}
-
-	/**
-	 * @param span
-	 * @return a new GridData for the horizontal 'span' value
-	 */
-	protected static GridData gridDataForLabel(int span) {
-		GridData gd = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
-		gd.horizontalSpan = span;
-		return gd;
-	}
-
-	// ------- ui creation
-
-	/**
-	 * Creates or returns the created label widget.
-	 * 
-	 * @param parent
-	 *            The parent composite or <code>null</code> if the widget has
-	 *            already been created.
-	 */
-	public Control getLabelControl(FormToolkit _formToolkit, Composite parent) {
-		Control control = null;
-		if ((_label == null || _label.isDisposed()) && (_hyperlink == null  || _hyperlink.isDisposed())) {
-			assertCompositeNotNull(parent);
-
-			String label = null;
-			if (_labelText != null && !"".equals(_labelText)) { //$NON-NLS-1$
-				//$NON-NLS-1$
-				label = _labelText;
-			} else {
-				label = "."; //$NON-NLS-1$
-			}
-
-			if (_listener == null) {
-				control = createLabel(_formToolkit, parent, label);
-			} else {
-				control = createHyperlink(_formToolkit, parent, label);
-			}
-			/**
-			 * if(isRequired) { FontData[] fontData =
-			 * parent.getFont().getFontData(); FontData[] newFontData = new
-			 * FontData[fontData.length]; for(int i=0; i<fontData.length; i++) {
-			 * newFontData[i] = new FontData(fontData[i].getName(),
-			 * fontData[i].getHeight(), fontData[i].getStyle() | SWT.BOLD); }
-			 * final Font font = new Font(control.getDisplay(),newFontData);
-			 * control.setFont(font); control.addDisposeListener(new
-			 * DisposeListener() {
-			 * 
-			 * public void widgetDisposed(DisposeEvent e) { font.dispose(); }
-			 * }); } else { control.setFont(parent.getFont()); }
-			 */
-			control.setFont(parent.getFont());
-			control.setEnabled(_enabled);
-		} else {
-			if (_label != null) {
-				control = _label;
-			} else {
-				control = _hyperlink;
-			}
-		}
-		return control;
-	}
-
-	/**
-	 * @param _formToolkit
-	 * @param parent
-	 * @return get the Label control for required
-	 */
-	public Control getRequiredLabelControl(FormToolkit _formToolkit,
-			Composite parent) {
-		if (_requiredLabel == null || _requiredLabel.isDisposed()) {
-			if (_formToolkit == null) {
-				_requiredLabel = new Label(parent, SWT.LEFT | SWT.WRAP);
-			} else {
-				_requiredLabel = _formToolkit.createLabel(parent, "", SWT.LEFT //$NON-NLS-1$
-						| SWT.WRAP);
-				_requiredLabel.setForeground(getLabelColor());
-			}
-			if (_isRequired) {
-				_requiredLabel.setText(DialogFieldResources.getInstance()
-						.getString("DialogFieldBase.Label.RequiredSymbol")); //$NON-NLS-1$
-			}
-		}
-		return _requiredLabel;
-	}
-
-	private Control createLabel(FormToolkit _formToolkit, Composite parent,
-			String labelString) {
-		if (_formToolkit == null) {
-			_label = new Label(parent, SWT.LEFT | SWT.WRAP);
-			_label.setText(labelString);
-		} else {
-			_label = _formToolkit.createLabel(parent, labelString, SWT.LEFT
-					| SWT.WRAP);
-			_label.setForeground(getLabelColor());
-		}
-		return _label;
-	}
-
-	/**
-	 * get color for label
-	 */
-	private Color getLabelColor() {
-		String osname = System.getProperty("os.name").toLowerCase(); //$NON-NLS-1$
-		if (osname.startsWith("mac os")) { //$NON-NLS-1$
-			return Display.getCurrent().getSystemColor(
-					SWT.COLOR_LIST_FOREGROUND);
-		}
-        return Display.getCurrent()
-                .getSystemColor(SWT.COLOR_LIST_SELECTION);
-	}
-
-	private Control createHyperlink(FormToolkit _formToolkit, Composite parent,
-			String label) {
-		if (_formToolkit == null) {
-			_hyperlink = new Hyperlink(parent, SWT.LEFT | SWT.WRAP);
-			_hyperlink.setForeground(getLabelColor());
-			_hyperlink.setUnderlined(true);
-			_hyperlink.addMouseTrackListener(new MouseTrackAdapter() {
-
-				public void mouseEnter(MouseEvent e) {
-					_hyperlink.setForeground(Display.getCurrent()
-							.getSystemColor(SWT.COLOR_BLUE));
-				}
-
-				public void mouseExit(MouseEvent e) {
-					_hyperlink.setForeground(getLabelColor());
-				}
-			});
-			_hyperlink.setText(label);
-		} else {
-			_hyperlink = _formToolkit.createHyperlink(parent, label, SWT.LEFT
-					| SWT.WRAP);
-		}
-		_hyperlink.addHyperlinkListener(_listener);
-		return _hyperlink;
-	}
-
-	/**
-	 * Creates a spacer control.
-	 * @param toolkit 
-	 * 
-	 * @param parent
-	 *            The parent composite
-	 * @return a spacer control
-	 */
-	public Control createEmptySpace(FormToolkit toolkit, Composite parent) {
-		return createEmptySpace(toolkit, parent, 1);
-	}
-
-	/**
-	 * Creates a spacer control with the given span. The composite is assumed to
-	 * have <code>MGridLayout</code> as layout.
-	 * @param toolkit 
-	 * 
-	 * @param parent
-	 *            The parent composite
-	 * @param span 
-	 * @return a label that creates empty space
-	 */
-	public Control createEmptySpace(FormToolkit toolkit, Composite parent,
-			int span) {
-		Label label;
-		if (toolkit != null) {
-			label = toolkit.createLabel(parent, ""); //$NON-NLS-1$
-		} else {
-			label = new Label(parent, SWT.LEFT);
-		}
-		GridData gd = new GridData();
-		gd.horizontalAlignment = GridData.BEGINNING;
-		gd.grabExcessHorizontalSpace = false;
-		gd.horizontalSpan = span;
-		gd.horizontalIndent = 0;
-		gd.widthHint = 0;
-		gd.heightHint = 0;
-		label.setLayoutData(gd);
-		return label;
-	}
-
-	/**
-	 * Tests is the control is not <code>null</code> and not disposed.
-	 * @param control 
-	 * @return true if the control is valid for use
-	 */
-	protected final boolean isOkToUse(Control control) {
-		return (control != null) && !(control.isDisposed());
-	}
-
-	// --------- enable / disable management
-
-	/**
-	 * Sets the enable state of the dialog field.
-	 */
-	public final void setEnabled(boolean enabled) {
-		if (enabled != _enabled) {
-			_enabled = enabled;
-			updateEnableState();
-		}
-	}
-
-	/**
-	 * Called when the enable state changed. To be extended by dialog field
-	 * implementors.
-	 */
-	protected void updateEnableState() {
-		if (_label != null && !_label.isDisposed()) {
-			_label.setEnabled(_enabled);
-		}
-		if (_hyperlink != null && !_hyperlink.isDisposed()) {
-			_hyperlink.setEnabled(_enabled);
-		}
-	}
-
-	/**
-	 * Gets the enable state of the dialog field.
-	 */
-	public final boolean isEnabled() {
-		return _enabled;
-	}
-
-	/**
-	 * @param comp
-	 */
-	protected final void assertCompositeNotNull(Composite comp) {
-		Assert.isNotNull(comp,
-				"uncreated control requested with composite null"); //$NON-NLS-1$
-	}
-
-	/**
-	 * @param nColumns
-	 */
-	protected final void assertEnoughColumns(int nColumns) {
-		Assert.isTrue(nColumns >= getNumberOfControls(),
-				"given number of columns is too small"); //$NON-NLS-1$
-	}
-
-	/**
-	 * Get attached data by key.
-	 * 
-	 * @param key
-	 * @return the attached data object for key
-	 */
-	public Object getAttachedData(Object key) {
-		if (_attachedData != null) {
-			return _attachedData.get(key);
-		}
-        return null;
-	}
-
-	/**
-	 * You can attach any data to the DialogField, and get it using the
-	 * <code>getAttachedData</code> method.
-	 * 
-	 * @param key
-	 * @param value
-	 */
-	public void putAttachedData(Object key, Object value) {
-		if (_attachedData == null) {
-			_attachedData = new HashMap();
-		}
-		_attachedData.put(key, value);
-	}
-
-	/**
-	 * this method give the DialogField a chance to set the correct column to
-	 * grab horizontal space. In the implementation of this method, should only
-	 * change the GridData of control, should not do anything else.
-	 * 
-	 * The caller is responsible to make sure the controls for the dialog field
-	 * has been created before calling this method.
-	 */
-	public void handleGrabHorizontal() {
-		// do nothing.
-	}
-
-	public boolean isRequired() {
-		return _isRequired;
-	}
-
-	/**
-	 * @param isRequired
-	 */
-	public void setRequired(boolean isRequired) {
-		this._isRequired = isRequired;
-	}
-
-	/**
-	 * @return gthe tool tip text
-	 */
-	protected String getToolTip() {
-		return toolTip;
-	}
-
-	public void setToolTip(String toolTip) {
-		this.toolTip = toolTip;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/DialogFieldGroup.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/DialogFieldGroup.java
deleted file mode 100644
index 0ed7b3a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/DialogFieldGroup.java
+++ /dev/null
@@ -1,113 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.ui.forms.widgets.FormToolkit;
-
-/**
- * This class represents a group of dialog fields, following the normal dialog
- * field's lifecycle.
- * 
- * The design of this class is to make a section could be reused in both dialog
- * environment and form based editor environment.
- * 
- * @author mengbo
- */
-public abstract class DialogFieldGroup {
-	private IDialogFieldChangeListener _defaultChangeListener;
-
-	private IDialogFieldApplyListener _defaultApplyListener;
-
-	/**
-	 * set default handler, should be called before <code>initialize()</code>
-	 * @param changelistener 
-	 * 
-	 */
-	public void setDefaultChangeListener(
-			IDialogFieldChangeListener changelistener) {
-		_defaultChangeListener = changelistener;
-	}
-
-	/**
-	 * Normally, the client should call this method in <code>initialize()</code>
-	 * for those field that wants to use the default event handler.
-	 * 
-	 * @return could be null
-	 */
-	public IDialogFieldChangeListener getDefaultChangeListener() {
-		return _defaultChangeListener;
-	}
-
-	/**
-	 * set default handler, should be called before <code>initialize()</code>
-	 * 
-	 * @param applylistener
-	 */
-	public void setDefaultApplyListener(IDialogFieldApplyListener applylistener) {
-		_defaultApplyListener = applylistener;
-	}
-
-	/**
-	 * Normally, the client should call this method in <code>initialize()</code>
-	 * for those field that wants to use the default event handler.
-	 * 
-	 * @return could be null
-	 */
-	public IDialogFieldApplyListener getDefaultApplyListener() {
-		return _defaultApplyListener;
-	}
-
-	/**
-	 * it is supposed to create all dialog fields and setup event listeners in
-	 * this method.
-	 * 
-	 * Normally client will create DialogFieldSection first, then
-	 * setDefaultChangeListener()/setDefaultApplyListener(), then call
-	 * initialize().
-	 */
-	public abstract void initialize();
-
-	/**
-	 * reload data from underlying model and set them into the dialog fields.
-	 * 
-	 */
-	public abstract void refreshData();
-
-	/**
-	 * layout the dialog fields.
-	 * 
-	 * @param toolkit
-	 *            could be null
-	 * @param parent
-	 * 
-	 */
-	public abstract void layoutDialogFields(FormToolkit toolkit,
-			Composite parent);
-
-	/**
-	 * validate whether the values in the dialog fields are valid. This method
-	 * should also enable/disable dialog fields based on their current value and
-	 * relationship
-	 * 
-	 * @return could return null. or an array containing null elements.
-	 */
-	public abstract IStatus[] validateDialogFields();
-	
-	/**
-	 * Intended to allow subclasses to recreate controls.  Default implementation does nothing.
-	 */
-	public void reset(){
-		//do nothing by default	
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/DialogFieldGroupPage.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/DialogFieldGroupPage.java
deleted file mode 100644
index 2e10f45..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/DialogFieldGroupPage.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.jface.wizard.WizardPage;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.widgets.Composite;
-
-/**
- * @author mengbo
- */
-public class DialogFieldGroupPage extends WizardPage {
-	private DialogFieldGroup _group;
-
-	private IDialogFieldChangeListener _defaultChangeListener = new IDialogFieldChangeListener() {
-		public void dialogFieldChanged(DialogField field) {
-			validate();
-		}
-	};
-
-	/**
-	 * @param pageName
-	 * @param section
-	 */
-	public DialogFieldGroupPage(String pageName, DialogFieldGroup section) {
-		super(pageName);
-		_group = section;
-		initializeGroup(_group);
-	}
-
-	/**
-	 * child class could override this method.
-	 * 
-	 * @param group
-	 */
-	protected void initializeGroup(DialogFieldGroup group) {
-		group.setDefaultChangeListener(_defaultChangeListener);
-		group.initialize();
-	}
-
-	public void createControl(Composite parent) {
-		Composite container = new Composite(parent, SWT.NONE);
-		_group.layoutDialogFields(null, container);
-		_group.refreshData();
-		validate();
-		this.setControl(container);
-	}
-
-	/**
-	 * @return the dialog field group
-	 */
-	public DialogFieldGroup getDialogFieldGroup() {
-		return _group;
-	}
-
-	/**
-	 * validate all the dialog fields.  Updates
-	 * status line and sets page completion if there are no errors
-	 */
-	private void validate() {
-		IStatus[] statuses = _group.validateDialogFields();
-		IStatus status = StatusUtil.getMostSevere(statuses);
-		StatusUtil.applyToStatusLine(this, status);
-		setPageComplete(status == null || status.getSeverity() != IStatus.ERROR);
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/DialogFieldResources.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/DialogFieldResources.java
deleted file mode 100644
index 30828e6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/DialogFieldResources.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
-
-import org.eclipse.jst.jsf.common.ui.JSFUICommonPlugin;
-import org.eclipse.jst.jsf.common.ui.internal.logging.Logger;
-import org.eclipse.jst.jsf.common.ui.internal.utils.ResourceUtils;
-
-/**
- * Resource bundle class for datastore wizard and it's pages
- * 
- * @author mengbo
- */
-/*package*/ class DialogFieldResources extends ResourceUtils {
-	/** Create the logger for this class */
-	private static Logger _log = JSFUICommonPlugin
-			.getLogger(DialogFieldResources.class);
-
-	private static DialogFieldResources _resource; // singleton
-
-	private static final String BUNDLE = DialogFieldResources.class.getName();
-
-	/**
-	 * Empty Constructor.
-	 * 
-	 * @return WizardsResources
-	 */
-
-	public static DialogFieldResources getInstance() {
-		if (_resource == null) {
-			_resource = new DialogFieldResources();
-		}
-		return _resource;
-	}
-
-	/**
-	 * The constructor create a resource bundle
-	 */
-	protected DialogFieldResources() {
-		try {
-			_resources = ResourceBundle.getBundle(BUNDLE);
-			// NOTE: this throws a runtime "MissingResourceException".
-		} catch (MissingResourceException ee) {
-			// Wizards.WizardResource.Error.ResourceNotFound = Unable to locate
-			// resource.
-			_log.error("Wizards.WizardResource.Error.ResourceNotFound", ee); //$NON-NLS-1$
-		}
-		setBundle(_resources, BUNDLE);
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/DialogFieldResources.properties b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/DialogFieldResources.properties
deleted file mode 100644
index ad34404..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/DialogFieldResources.properties
+++ /dev/null
@@ -1,48 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-##################################################################
-# Resource message for SourceFolderButtonDialogField.
-##################################################################
-SourceFolderButtonDialogField.container.label = Source Folder:
-SourceFolderButtonDialogField.container.button = Browse...
-
-SourceFolderButtonDialogField.ChooseSourceContainerDialog.Title = Folder Selection
-SourceFolderButtonDialogField.ChooseSourceContainerDialog.Description = Choose a folder:
-
-SourceFolderButtonDialogField.error.EnterContainerName = Folder name is empty.
-SourceFolderButtonDialogField.error.NotSameProject = The project should be \''{0}\''.
-SourceFolderButtonDialogField.error.ContainerIsBinary=''{0}'' is a JAR archive.
-SourceFolderButtonDialogField.error.ContainerDoesNotExist=Folder ''{0}'' does not exist.
-SourceFolderButtonDialogField.error.NotAFolder=''{0}'' must be a project or folder.
-SourceFolderButtonDialogField.error.ProjectClosed=Project ''{0}'' must be accessible.
-SourceFolderButtonDialogField.warning.NotAJavaProject=Folder ''{0}'' is not a Java project.
-SourceFolderButtonDialogField.warning.NotInAJavaProject=Folder ''{0}'' is not in a Java project.
-SourceFolderButtonDialogField.warning.NotOnClassPath=Folder ''{0}'' is not on the Java build class path.
-
-
-##################################################################
-# Resource message for PackageButtonDialogField.
-##################################################################
-PackageButtonDialogField.package.label=Pac&kage:
-PackageButtonDialogField.package.button=Bro&wse...
-
-PackageButtonDialogField.error.InvalidPackageName=Package name  ''{0}'' is not valid.
-PackageButtonDialogField.error.ClashOutputLocation=Package clashes with project output folder.
-PackageButtonDialogField.warning.DiscouragedPackageName=This package name ''{0}'' is discouraged. 
-PackageButtonDialogField.warning.DefaultPackageDiscouraged=The use of the default package is discouraged.
-
-PackageButtonDialogField.ChoosePackageDialog.title=Package Selection
-PackageButtonDialogField.ChoosePackageDialog.description=&Choose a folder:
-PackageButtonDialogField.ChoosePackageDialog.empty=Cannot find packages to select.
-
-ClassButtonDialogField.Alert.Title=Error Open Type
-ClassButtonDialogField.Alert.Msg=The project does not have Java Nature.
-DialogFieldBase.Label.RequiredSymbol=*
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/IDialogFieldApplyListener.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/IDialogFieldApplyListener.java
deleted file mode 100644
index e8be7b8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/IDialogFieldApplyListener.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-
-/**
- * @author mengbo
- */
-public interface IDialogFieldApplyListener {
-	/**
-	 * when the DialogField believe it should apply its value in UI, will fire
-	 * this event.
-	 * 
-	 * Normally, for text input, when user is typing, will only fire
-	 * dialogFieldChanged(), when lose focus will fire dialogFieldApplied().
-	 * 
-	 * For other control, such as readonly combo box, whenever user change
-	 * selection, will fire both dialogFieldChanged() and dialogFieldApplied()
-	 * 
-	 * @param field
-	 */
-	void dialogFieldApplied(DialogField field);
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/IDialogFieldChangeListener.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/IDialogFieldChangeListener.java
deleted file mode 100644
index b5ead67..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/IDialogFieldChangeListener.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-
-/**
- * Change listener used by <code>DialogField</code>
- * 
- * @author mengbo
- */
-public interface IDialogFieldChangeListener {
-
-	/**
-	 * The dialog field has changed.
-	 * @param field
-	 */
-	void dialogFieldChanged(DialogField field);
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/IStringButtonAdapter.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/IStringButtonAdapter.java
deleted file mode 100644
index 466e355..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/IStringButtonAdapter.java
+++ /dev/null
@@ -1,24 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-
-/**
- * Change listener used by <code>StringButtonDialogField</code>
- */
-public interface IStringButtonAdapter {
-
-	/**
-	 * @param field
-	 */
-	void changeControlPressed(DialogField field);
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/ISupportTextValue.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/ISupportTextValue.java
deleted file mode 100644
index 014752d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/ISupportTextValue.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-/**
- * DialogField can choose to also implement this interface. The purpose of this
- * interface is to make DialogFields to be more easily used to edit element
- * attributes, since attributes are all of string type.
- * 
- * @author mengbo
- * @version 1.5
- */
-public interface ISupportTextValue {
-	/**
-	 * @param value
-	 */
-	public void setTextWithoutUpdate(String value);
-
-	/**
-	 * @return the text
-	 */
-	public String getText();
-
-	/**
-	 * @param value
-	 */
-	public void setText(String value);
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/JavaClassWizard.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/JavaClassWizard.java
deleted file mode 100644
index 7458740..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/JavaClassWizard.java
+++ /dev/null
@@ -1,186 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import java.lang.reflect.InvocationTargetException;
-import java.util.List;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.jdt.core.IJavaElement;
-import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.core.JavaCore;
-import org.eclipse.jdt.ui.JavaUI;
-import org.eclipse.jface.dialogs.IDialogSettings;
-import org.eclipse.jface.operation.IRunnableWithProgress;
-import org.eclipse.jface.wizard.Wizard;
-import org.eclipse.jst.jsf.common.ui.JSFUICommonPlugin;
-import org.eclipse.ui.IWorkbenchPage;
-import org.eclipse.ui.IWorkbenchWindow;
-import org.eclipse.ui.PlatformUI;
-import org.eclipse.ui.actions.WorkspaceModifyOperation;
-import org.eclipse.ui.ide.IDE;
-import org.eclipse.ui.wizards.newresource.BasicNewResourceWizard;
-
-/**
- * @author mengbo
- */
-/*package*/ class JavaClassWizard extends Wizard {
-	private static String STORE_SECTION = "JavaClassWizard"; //$NON-NLS-1$
-
-	private JavaClassWizardPage _mainPage;
-
-	private String _className, _classArgs;
-
-	private IProject _project;
-
-	private String _superClass;
-
-	private List _interfaceList;
-
-	private boolean _autoOpenResource = true;
-
-	/**
-	 * @param autoOpenResource
-	 */
-	public void setAutoOpenResource(boolean autoOpenResource) {
-		_autoOpenResource = autoOpenResource;
-	}
-
-	/**
-	 * @param project
-	 * @param className
-	 */
-	public JavaClassWizard(IProject project, String className) {
-		this(project, className, null, null);
-	}
-
-	/**
-	 * @param project
-	 * @param className
-	 * @param superClass
-	 * @param superInterfaces
-	 */
-	public JavaClassWizard(IProject project, String className,
-			String superClass, List superInterfaces) {
-		this._project = project;
-		this._className = className;
-		this._superClass = superClass;
-		this._interfaceList = superInterfaces;
-		IDialogSettings masterSettings = JSFUICommonPlugin.getDefault()
-				.getDialogSettings();
-		setDialogSettings(getSettingsSection(masterSettings));
-		setWindowTitle(JSFUICommonPlugin
-				.getResourceString("DialogField.JavaClassWizard.NewClass"));//$NON-NLS-1$
-		setNeedsProgressMonitor(true);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jface.wizard.IWizard#addPages()
-	 */
-	public void addPages() {
-		_mainPage = new JavaClassWizardPage(_project, _className, _superClass,
-				_interfaceList);
-		addPage(_mainPage);
-		_mainPage.init();
-	}
-
-	private IDialogSettings getSettingsSection(IDialogSettings master) {
-		IDialogSettings setting = master.getSection(STORE_SECTION);
-		if (setting == null) {
-			setting = master.addNewSection(STORE_SECTION);
-		}
-		return setting;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jface.wizard.IWizard#performFinish()
-	 */
-	public boolean performFinish() {
-		if (_mainPage.getPackageText() != null
-				&& _mainPage.getPackageText().length() > 0) {
-			StringBuffer buffer = new StringBuffer(_mainPage.getPackageText());
-			buffer.append(".");//$NON-NLS-1$
-			buffer.append(_mainPage.getTypeName());
-			_className = buffer.toString();
-		} else {
-			_className = _mainPage.getTypeName();
-		}
-		_classArgs = _mainPage.getClassArgs();
-		IRunnableWithProgress op = new WorkspaceModifyOperation() {
-			protected void execute(IProgressMonitor monitor)
-					throws CoreException, InvocationTargetException,
-					InterruptedException {
-				_mainPage.createType(monitor);
-				IResource resource = _mainPage.getModifiedResource();
-				if (resource != null && _autoOpenResource) {
-					selectAndReveal(resource);
-					if (_project.hasNature(JavaCore.NATURE_ID)) {
-						IJavaProject jProject = JavaCore.create(_project);
-						IJavaElement jElement = jProject.findElement(resource
-								.getProjectRelativePath()
-								.removeFirstSegments(1));
-						if (jElement != null) {
-							JavaUI.openInEditor(jElement);
-						}
-					} else if (resource instanceof IFile) {
-						IWorkbenchPage page = PlatformUI.getWorkbench()
-								.getActiveWorkbenchWindow().getActivePage();
-						IDE.openEditor(page, (IFile) resource, true);
-					}
-				}
-			}
-
-		};
-		try {
-			getContainer().run(false, true, op);
-		} catch (InvocationTargetException e) {
-			e.printStackTrace(); // PDEPlugin.logException(e);
-		} catch (InterruptedException e) {
-			e.printStackTrace();// PDEPlugin.logException(e);
-		}
-		return true;
-	}
-
-	private void selectAndReveal(IResource newResource) {
-		BasicNewResourceWizard.selectAndReveal(newResource,
-				getWorkbenchWindow());
-	}
-
-	private IWorkbenchWindow getWorkbenchWindow() {
-		return PlatformUI.getWorkbench().getActiveWorkbenchWindow();
-	}
-
-	private String getClassName() {
-		return _className;
-	}
-
-	/**
-	 * @return the class name including args
-	 */
-	public String getClassNameWithArgs() {
-		if (_classArgs != null && _classArgs.length() > 0) {
-			StringBuffer buffer = new StringBuffer(_className);
-			buffer.append(":");//$NON-NLS-1$
-			buffer.append(_classArgs);
-			return buffer.toString();
-		}
-		return getClassName();
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/JavaClassWizardPage.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/JavaClassWizardPage.java
deleted file mode 100644
index b445c60..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/JavaClassWizardPage.java
+++ /dev/null
@@ -1,249 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import java.util.List;
-
-import org.eclipse.core.resources.IFolder;
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.core.IPackageFragment;
-import org.eclipse.jdt.core.IPackageFragmentRoot;
-import org.eclipse.jdt.core.JavaConventions;
-import org.eclipse.jdt.core.JavaCore;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jdt.ui.wizards.NewClassWizardPage;
-
-/**
- * @author mengbo
- */
-/*package*/ class JavaClassWizardPage extends NewClassWizardPage {
-	private String _className;
-
-	private final IProject _project;
-
-	private final InitialClassProperties _initialValues;
-
-	private IJavaProject _javaProject;
-
-	private IStatus _fClassNameStatus, _fPackageNameStatus;
-
-	private final static String  SOURCE_COMPLIANCE_1_3 = JavaCore.VERSION_1_3;
-	
-	static class InitialClassProperties {
-		// populate new wizard page
-		private String superClassName;
-
-		private List interfacesName;
-
-		private String className;
-
-		private String classArgs;
-
-		private String packageName;
-
-		private IPackageFragmentRoot packageFragmentRoot;
-
-		private IPackageFragment packageFragment;
-
-		InitialClassProperties() {
-			this.superClassName = ""; //$NON-NLS-1$
-			this.interfacesName = null;
-			this.className = null;
-			this.classArgs = null;
-			this.packageName = null;
-			this.packageFragment = null;
-			this.packageFragmentRoot = null;
-		}
-	}
-
-	/**
-	 * @param project
-	 * @param className
-	 * @param superClassName
-	 * @param interfacesName
-	 */
-	public JavaClassWizardPage(IProject project, String className,
-			String superClassName, List interfacesName) {
-		super();
-		this._className = className;
-		this._project = project;
-		try {
-			if (project != null && project.hasNature(JavaCore.NATURE_ID)) {
-				this._javaProject = JavaCore.create(project);
-			} else {
-				this._javaProject = null;
-			}
-		} catch (CoreException e) {
-			e.printStackTrace();// PDEPlugin.logException(e);
-		}
-		_initialValues = new InitialClassProperties();
-		_initialValues.className = className;
-		_initialValues.superClassName = superClassName;
-		_initialValues.interfacesName = interfacesName;
-	}
-
-	/**
-	 * @param project
-	 * @param className
-	 */
-	public JavaClassWizardPage(IProject project, String className) {
-		this(project, className, null, null);
-	}
-
-	/**
-	 * Call when page is added to wizard to initialize
-	 */
-	public void init() {
-		initializeExpectedValues();
-		initializeWizardPage();
-	}
-
-	private void initializeExpectedValues() {
-		// source folder name, package name, class name
-		int loc = _className.indexOf(":"); //$NON-NLS-1$
-		if (loc != -1) {
-			if (loc < _className.length()) {
-				_initialValues.classArgs = _className.substring(loc + 1,
-						_className.length());
-				_className = _className.substring(0, loc);
-			}
-			if (loc > 0) {
-				_initialValues.className = _className.substring(0, loc);
-			} else if (loc == 0) {
-				_initialValues.className = ""; //$NON-NLS-1$
-			}
-		}
-		_fClassNameStatus = JavaConventions
-		    .validateJavaTypeName(_initialValues.className, SOURCE_COMPLIANCE_1_3,SOURCE_COMPLIANCE_1_3);
-
-		loc = _className.lastIndexOf('.');
-		if (loc != -1) {
-			_initialValues.packageName = _className.substring(0, loc);
-			_initialValues.className = _className.substring(loc + 1);
-			_fPackageNameStatus = JavaConventions
-                    .validateJavaTypeName(_initialValues.packageName, SOURCE_COMPLIANCE_1_3,SOURCE_COMPLIANCE_1_3);
-			_fClassNameStatus = JavaConventions
-                    .validateJavaTypeName(_initialValues.className, SOURCE_COMPLIANCE_1_3,SOURCE_COMPLIANCE_1_3);
-		}
-		if (_javaProject == null) {
-			return;
-		}
-		try {
-			if (_initialValues.packageFragmentRoot == null) {
-				IPackageFragmentRoot srcEntryDft = null;
-				IPackageFragmentRoot[] roots = _javaProject
-						.getPackageFragmentRoots();
-				for (int i = 0; i < roots.length; i++) {
-					if (roots[i].getKind() == IPackageFragmentRoot.K_SOURCE) {
-						srcEntryDft = roots[i];
-						break;
-					}
-				}
-				if (srcEntryDft != null) {
-					_initialValues.packageFragmentRoot = srcEntryDft;
-				} else {
-					_initialValues.packageFragmentRoot = _javaProject
-							.getPackageFragmentRoot(_javaProject.getResource());
-				}
-				if (_initialValues.packageFragment == null
-						&& _initialValues.packageFragmentRoot != null
-						&& _initialValues.packageName != null
-						&& _initialValues.packageName.length() > 0) {
-					IFolder packageFolder = _project
-							.getFolder(_initialValues.packageName);
-					_initialValues.packageFragment = _initialValues.packageFragmentRoot
-							.getPackageFragment(packageFolder
-									.getProjectRelativePath().toOSString());
-				}
-			}
-			// superclass and interface
-			if (_initialValues.superClassName == null) {
-				_initialValues.superClassName = "java.lang.Object"; //$NON-NLS-1$
-			}
-//			_initialValues.superClassType = findTypeForName(_initialValues.superClassName);
-		} catch (JavaModelException e) {
-			e.printStackTrace();// PDEPlugin.logException(e);
-		}
-	}
-
-	/**
-	 * initialize the wizard page
-	 */
-	protected void initializeWizardPage() {
-		setPackageFragmentRoot(_initialValues.packageFragmentRoot, true);
-		setPackageFragment(_initialValues.packageFragment, true);
-		setEnclosingType(null, true);
-		setEnclosingTypeSelection(false, true);
-		setTypeName(_initialValues.className, true);
-		setSuperClass(_initialValues.superClassName, true);
-		if (_initialValues.interfacesName != null) {
-			setSuperInterfaces(_initialValues.interfacesName, true);
-		}
-		boolean hasSuperClass = _initialValues.superClassName != null
-				&& _initialValues.superClassName.length() > 0;
-		boolean hasInterface = _initialValues.interfacesName != null
-				&& _initialValues.interfacesName.size() > 0;
-		setMethodStubSelection(false, hasSuperClass, hasInterface
-				|| hasSuperClass, true);
-	}
-
-//	private IType findTypeForName(String typeName) throws JavaModelException {
-//		if (typeName == null || typeName.length() == 0) {
-//			return null;
-//		}
-//		IType type = null;
-//		String fileName = typeName.replace('.', '/') + ".java"; //$NON-NLS-1$
-//		IJavaElement element = _javaProject.findElement(new Path(fileName));
-//		if (element == null) {
-//			return null;
-//		}
-//		if (element instanceof IClassFile) {
-//			type = ((IClassFile) element).getType();
-//		} else if (element instanceof ICompilationUnit) {
-//			IType[] types = ((ICompilationUnit) element).getTypes();
-//			type = types[0];
-//		}
-//		return type;
-//	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jdt.ui.wizards.NewClassWizardPage#setVisible(boolean)
-	 */
-	public void setVisible(boolean visible) {
-		super.setVisible(visible);
-		// policy: wizards are not allowed to come up with an error message;
-		// in this wizard, some fields may need initial validation and thus,
-		// potentially start with an error message.
-		if (_fClassNameStatus != null && !_fClassNameStatus.isOK()) {
-			updateStatus(_fClassNameStatus);
-		}
-		if (_fPackageNameStatus != null && !_fPackageNameStatus.isOK()) {
-			updateStatus(_fPackageNameStatus);
-		}
-	}
-
-	/**
-	 * @return the class arguments or "" if not set
-	 */
-	public String getClassArgs() {
-		if (_initialValues.classArgs == null) {
-			return ""; //$NON-NLS-1$
-		}
-		return _initialValues.classArgs;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/JavaSearchScope.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/JavaSearchScope.java
deleted file mode 100644
index 8ac5807..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/JavaSearchScope.java
+++ /dev/null
@@ -1,221 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.jdt.core.IClasspathEntry;
-import org.eclipse.jdt.core.IJavaElement;
-import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.core.ITypeHierarchy;
-import org.eclipse.jdt.core.JavaCore;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jdt.core.search.IJavaSearchScope;
-import org.eclipse.jst.jsf.common.ui.IFileFolderConstants;
-
-/**
- * @author mengbo
- */
-/*package*/ class JavaSearchScope implements IJavaSearchScope {
-	private final IProject _project;
-
-	private final String _superType;
-
-	private HashSet _allowedTypeSet;
-
-	private IPath[] _enclosingProjectsAndJars;
-
-	private IProject[] _relativeProjects;
-
-	/**
-	 * @param project
-	 * @param superType
-	 */
-	public JavaSearchScope(IProject project, String superType) {
-		this._project = project;
-		this._superType = superType;
-		computeRelativeProjects();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jdt.core.search.IJavaSearchScope#enclosingProjectsAndJars()
-	 */
-	public IPath[] enclosingProjectsAndJars() {
-		if (_enclosingProjectsAndJars == null) {
-			ArrayList list = new ArrayList();
-			for (int i = 0; i < _relativeProjects.length; i++) {
-				try {
-					if (_relativeProjects[i].hasNature(JavaCore.NATURE_ID)) {
-						IJavaProject javaProject = JavaCore
-								.create(_relativeProjects[i]);
-						IClasspathEntry[] classpath = javaProject
-								.getResolvedClasspath(true);
-						for (int j = 0; j < classpath.length; j++) {
-							list.add(classpath[j].getPath());
-						}
-						list.add(javaProject.getPath());
-					}
-				} catch (CoreException e)// NOPMD
-				{
-					// skip the project.
-				}
-			}
-			_enclosingProjectsAndJars = (IPath[]) list.toArray(new IPath[(list
-					.size())]);
-		}
-		return _enclosingProjectsAndJars;
-	}
-
-	private void computeRelativeProjects() {
-		try {
-			IProject[] referencedProjects = _project.getReferencedProjects();
-			_relativeProjects = new IProject[referencedProjects.length + 1];
-			System.arraycopy(referencedProjects, 0, _relativeProjects, 1,
-					referencedProjects.length);
-			_relativeProjects[0] = _project;
-		} catch (CoreException e) {
-			_relativeProjects = new IProject[] { _project };
-		}
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jdt.core.search.IJavaSearchScope#encloses(java.lang.String)
-	 */
-	public boolean encloses(String resourcePath) {
-		if (_allowedTypeSet == null) {
-			try {
-				_allowedTypeSet = findAllowedTypes(_superType);
-			} catch (CoreException e) {
-				e.printStackTrace();
-			}
-		}
-		if (_allowedTypeSet == null) {
-			_allowedTypeSet = new HashSet();
-		}
-		int separatorIndex = resourcePath.indexOf(JAR_FILE_ENTRY_SEPARATOR);
-		if (separatorIndex != -1) {
-			String className = resourcePath.substring(separatorIndex + 1,
-					resourcePath.length() - 6).replace('/', '.');
-			if (_allowedTypeSet.contains(className)) {
-				return true;
-			}
-		} else if (_allowedTypeSet.contains(resourcePath)) {
-			return true;
-		}
-		return false;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jdt.core.search.IJavaSearchScope#encloses(org.eclipse.jdt.core.IJavaElement)
-	 */
-	public boolean encloses(IJavaElement element) {
-		return encloses(element.getPath().toString());
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jdt.core.search.IJavaSearchScope#includesBinaries()
-	 */
-	public boolean includesBinaries() {
-		return true;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jdt.core.search.IJavaSearchScope#includesClasspaths()
-	 */
-	public boolean includesClasspaths() {
-		return true;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jdt.core.search.IJavaSearchScope#setIncludesBinaries(boolean)
-	 */
-	public void setIncludesBinaries(boolean includesBinaries) {
-	    //    do nothing, includeBinaries always true
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jdt.core.search.IJavaSearchScope#setIncludesClasspaths(boolean)
-	 */
-	public void setIncludesClasspaths(boolean includesClasspaths) {
-        // do nothing, includeClasspaths always trues
-	}
-
-	private HashSet findAllowedTypes(String superType) throws CoreException {
-		HashSet set = new HashSet();
-
-		IProject[] projects = _relativeProjects;
-
-		for (int i = 0; i < projects.length; i++) {
-			IType type = null;
-			if (projects[i].hasNature(JavaCore.NATURE_ID)) {
-				IJavaProject javaProject = JavaCore.create(projects[i]);
-				if (superType != null) {
-					try {
-						type = javaProject.findType(superType);
-						if (type != null) {
-							ITypeHierarchy typeHierarchy = type
-									.newTypeHierarchy(javaProject, null);
-							IType[] subtypes = typeHierarchy
-									.getAllSubtypes(type);
-							for (int j = 0; j < subtypes.length; j++) {
-								if (!subtypes[j].isBinary()) {
-									set.add(subtypes[j].getPath().toString());
-								} else {
-									String path = subtypes[j].getPath()
-											.toString();
-									if (path != null
-											&& path
-													.endsWith(IFileFolderConstants.DOT
-															+ IFileFolderConstants.EXT_JAR)) {
-										set.add(subtypes[j]
-												.getFullyQualifiedName());
-									} else {
-										set.add(path);
-									}
-								}
-							}
-						}
-					} catch (JavaModelException e) {
-						e.printStackTrace();
-					}
-				}
-			}
-		}
-		return set;
-	}
-
-	/**
-	 * @return Returns the superType.
-	 */
-	public String getSuperType() {
-		return _superType;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/JavaSearchScopeDecorator.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/JavaSearchScopeDecorator.java
deleted file mode 100644
index 94cd55c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/JavaSearchScopeDecorator.java
+++ /dev/null
@@ -1,139 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.jdt.core.IJavaElement;
-import org.eclipse.jdt.core.search.IJavaSearchScope;
-
-/**
- * @author mengbo
- * @version 1.5
- */
-/*package*/ class JavaSearchScopeDecorator implements IJavaSearchScope {
-	JavaSearchScope[] _scopes = new JavaSearchScope[0];
-
-	/**
-	 * @param project
-	 * @param superTypes
-	 */
-	public JavaSearchScopeDecorator(IProject project, List superTypes) {
-		List scopeList = new ArrayList();
-		if (superTypes != null) {
-			for (int i = 0; i < superTypes.size(); i++) {
-				scopeList.add(new JavaSearchScope(project, superTypes.get(i)
-						.toString()));
-			}
-		}
-		_scopes = (JavaSearchScope[]) scopeList
-				.toArray(new JavaSearchScope[scopeList.size()]);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jdt.core.search.IJavaSearchScope#encloses(java.lang.String)
-	 */
-	public boolean encloses(String resourcePath) {
-		for (int i = 0; i < _scopes.length; i++) {
-			if (_scopes[i].encloses(resourcePath) == true) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jdt.core.search.IJavaSearchScope#encloses(org.eclipse.jdt.core.IJavaElement)
-	 */
-	public boolean encloses(IJavaElement element) {
-		for (int i = 0; i < _scopes.length; i++) {
-			if (_scopes[i].encloses(element) == true) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jdt.core.search.IJavaSearchScope#enclosingProjectsAndJars()
-	 */
-	public IPath[] enclosingProjectsAndJars() {
-		Set set = new HashSet();
-		for (int i = 0; i < _scopes.length; i++) {
-			set.addAll(Arrays.asList(_scopes[i].enclosingProjectsAndJars()));
-		}
-		return (IPath[]) set.toArray(new IPath[set.size()]);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jdt.core.search.IJavaSearchScope#includesBinaries()
-	 */
-	public boolean includesBinaries() {
-		for (int i = 0; i < _scopes.length; i++) {
-			if (_scopes[i].includesBinaries() == true) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jdt.core.search.IJavaSearchScope#includesClasspaths()
-	 */
-	public boolean includesClasspaths() {
-		for (int i = 0; i < _scopes.length; i++) {
-			if (_scopes[i].includesClasspaths() == true) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jdt.core.search.IJavaSearchScope#setIncludesBinaries(boolean)
-	 */
-	public void setIncludesBinaries(boolean includesBinaries) {
-		for (int i = 0; i < _scopes.length; i++) {
-			_scopes[i].setIncludesBinaries(includesBinaries);
-		}
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jdt.core.search.IJavaSearchScope#setIncludesClasspaths(boolean)
-	 */
-	public void setIncludesClasspaths(boolean includesClasspaths) {
-		for (int i = 0; i < _scopes.length; i++) {
-			_scopes[i].setIncludesClasspaths(includesClasspaths);
-		}
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/JavaUIHelper.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/JavaUIHelper.java
deleted file mode 100644
index 8bee860..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/JavaUIHelper.java
+++ /dev/null
@@ -1,140 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.jdt.core.IJavaElement;
-import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.core.JavaCore;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jdt.core.search.IJavaSearchScope;
-import org.eclipse.jdt.core.search.SearchEngine;
-import org.eclipse.jdt.ui.JavaUI;
-import org.eclipse.jface.dialogs.ProgressMonitorDialog;
-import org.eclipse.jst.jsf.common.ui.JSFUICommonPlugin;
-import org.eclipse.swt.widgets.Shell;
-import org.eclipse.ui.IWorkbenchPage;
-import org.eclipse.ui.PartInitException;
-import org.eclipse.ui.PlatformUI;
-import org.eclipse.ui.dialogs.SelectionDialog;
-import org.eclipse.ui.ide.IDE;
-
-/**
- * @author mengbo
- */
-public final class JavaUIHelper {
-	/**
-	 * @param project
-	 * @param className
-	 */
-	static void doOpenClass(IProject project, String className) {
-		String path = className.replace('.', '/') + ".java"; //$NON-NLS-1$
-		try {
-			if (project.hasNature(JavaCore.NATURE_ID)) {
-				IJavaProject javaProject = JavaCore.create(project);
-				IJavaElement result = javaProject.findElement(new Path(path));
-				JavaUI.openInEditor(result);
-			} else {
-				IResource resource = project.findMember(new Path(path));
-				if (resource instanceof IFile) {
-					IWorkbenchPage page = PlatformUI.getWorkbench()
-							.getActiveWorkbenchWindow().getActivePage();
-					IDE.openEditor(page, (IFile) resource, true);
-				}
-			}
-		} catch (PartInitException e) {
-			e.printStackTrace();// PDEPlugin.logException(e);
-		} catch (JavaModelException e) {
-			e.printStackTrace();// Display.getCurrent().beep();
-		} catch (CoreException e) {
-			e.printStackTrace();// PDEPlugin.logException(e);
-		}
-	}
-
-	/**
-	 * @param project
-	 * @param className
-	 * @return true if the class exists in project
-	 */
-	static boolean doesClassExist(IProject project, String className) {
-		String path = className.replace('.', '/') + ".java"; //$NON-NLS-1$
-		try {
-			if (project.hasNature(JavaCore.NATURE_ID)) {
-				IJavaProject javaProject = JavaCore.create(project);
-
-				IJavaElement result = javaProject.findElement(new Path(path));
-				return result != null;
-			}
-            IResource resource = project.findMember(new Path(path));
-            return resource != null;
-		} catch (JavaModelException e) {
-			return false;
-		} catch (CoreException e) {
-			return false;
-		}
-	}
-
-	/**
-	 * @param shell
-	 * @param searchScope
-	 * @param typeFlag
-	 * @return the selection dialog
-	 */
-	static SelectionDialog openSelectionDialog(Shell shell,
-			IJavaSearchScope searchScope, int typeFlag) {
-		try {
-			return JavaUI.createTypeDialog(shell, new ProgressMonitorDialog(
-					shell), searchScope, typeFlag, false);
-		} catch (JavaModelException e) {
-            JSFUICommonPlugin.getLogger(JavaUIHelper.class).error(e);
-			return null;
-		}
-	}
-
-	/**
-	 * @param shell
-	 * @param project
-	 * @param superType
-	 * @param typeFlag
-	 * @return the selection  dialog
-	 */
-	public static SelectionDialog openSelectionDialog(Shell shell,
-			IProject project, String superType, int typeFlag) {
-		IJavaSearchScope searchScope = findSearchScope(project, superType);
-		return openSelectionDialog(shell, searchScope, typeFlag);
-	}
-
-	/**
-	 * @param project
-	 * @param superType
-	 * @return the search scope
-	 */
-	static IJavaSearchScope findSearchScope(IProject project,
-			String superType) {
-		if (project != null) {
-			if (superType == null || "".equals(superType)) { //$NON-NLS-1$
-				superType = "java.lang.Object";//$NON-NLS-1$
-			}
-			return new JavaSearchScope(project, superType);
-		}
-		return SearchEngine.createWorkspaceScope();
-	}
-	
-	private JavaUIHelper()
-	{
-		// static helper, no instantiation
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/LayoutUtil.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/LayoutUtil.java
deleted file mode 100644
index 2457cd1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/LayoutUtil.java
+++ /dev/null
@@ -1,116 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import org.eclipse.jface.dialogs.Dialog;
-import org.eclipse.jface.resource.JFaceResources;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.graphics.FontMetrics;
-import org.eclipse.swt.graphics.GC;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.widgets.Button;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Text;
-import org.eclipse.ui.forms.widgets.FormToolkit;
-
-/**
- * A layout utility class
- *
- */
-public final class LayoutUtil {
-	// The Text control looks higher then Button control when they have the same
-	// height,
-	// Increasing the height of 5 pixels will make them looks the same height.
-	private final static int BUTTON_HEIGHT_ADJUSTMENT = 5;
-
-
-	/**
-	 * @param control
-	 * @param grab
-	 */
-	public static void setGrabHorizontal(Control control, boolean grab) {
-		Object ld = control.getLayoutData();
-		if (ld instanceof GridData) {
-			((GridData) ld).grabExcessHorizontalSpace = grab;
-		}
-	}
-
-	/**
-	 * Sets the width hint of a control. Assumes that GridData is used.
-	 * @param control 
-	 * @param widthHint 
-	 */
-	public static void setWidthHint(Control control, int widthHint) {
-		Object ld = control.getLayoutData();
-		if (ld instanceof GridData) {
-			((GridData) ld).widthHint = widthHint;
-		}
-	}
-
-
-	/**
-	 * Sets the horizontal indent of a control. Assumes that GridData is used.
-	 * @param control 
-	 * @param horizontalIndent 
-	 */
-	static void setHorizontalIndent(Control control, int horizontalIndent) {
-		Object ld = control.getLayoutData();
-		if (ld instanceof GridData) {
-			((GridData) ld).horizontalIndent = horizontalIndent;
-		}
-	}
-
-	/**
-	 * Sets the horizontal indent of a control. Assumes that GridData is used.
-	 * @param control 
-	 */
-	public static void setHorizontalGrabbing(Control control) {
-		Object ld = control.getLayoutData();
-		if (ld instanceof GridData) {
-			((GridData) ld).grabExcessHorizontalSpace = true;
-		}
-	}
-
-	/**
-	 * Returns a width hint for a button control.
-	 * @param button 
-	 * @return the hint value
-	 */
-	static int getButtonWidthHint(Button button) {
-		if (button.getFont().equals(JFaceResources.getDefaultFont()))
-			button.setFont(JFaceResources.getDialogFont());
-
-		GC gc = new GC(button);
-		gc.setFont(button.getFont());
-		FontMetrics fontMetrics = gc.getFontMetrics();
-		gc.dispose();
-
-		int length = button.getText().length();
-		int widthHint = Dialog.convertWidthInCharsToPixels(fontMetrics,
-				length < 2 ? 2 : length);
-		return Math.max(widthHint, button.computeSize(SWT.DEFAULT, SWT.DEFAULT,
-				true).x);
-	}
-
-	static int getButtonHeightHint(FormToolkit toolkit, Text text) {
-		if (toolkit != null) {
-			return text.computeSize(SWT.DEFAULT, SWT.DEFAULT, true).y
-					+ BUTTON_HEIGHT_ADJUSTMENT;
-		}
-        return text.computeSize(SWT.DEFAULT, SWT.DEFAULT, true).y;
-	}
-	
-	private LayoutUtil()
-	{
-		// static utility class; no instantiation
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/RadiosDialogField.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/RadiosDialogField.java
deleted file mode 100644
index 7db537b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/RadiosDialogField.java
+++ /dev/null
@@ -1,233 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.SelectionAdapter;
-import org.eclipse.swt.events.SelectionEvent;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.layout.RowLayout;
-import org.eclipse.swt.widgets.Button;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.ui.forms.widgets.FormToolkit;
-
-/**
- * This will display a labal and a group of radio buttons. The group of radio
- * buttons will be layed out horizontally use a RowLayout, and them as a group
- * will use one cell in the GridLayout.
- * 
- * Whenever the radios selection change will fire both dialogFieldChanged() and
- * dialogFieldApplied() event.
- * 
- * @author mengbo
- */
-public class RadiosDialogField extends DialogFieldBase {
-	final static private String INDEXKEY = "INDEX"; //$NON-NLS-1$
-
-	private Composite _group;
-
-	private String[] _items;
-
-	private Button[] _button;
-
-	private int _selectIndex = -1;
-
-	private boolean _fireEvent = true;
-
-	/**
-	 * Default constructor
-	 */
-	public RadiosDialogField() {
-		super();
-	}
-
-	/**
-	 * this method must be called before create control
-	 * 
-	 * @param items
-	 */
-	public void setItems(String[] items) {
-		_items = items;
-		_button = new Button[_items.length];
-	}
-
-	// ------- layout helpers
-
-	/*
-	 * @see DialogField#doFillIntoGrid
-	 */
-	public Control[] doFillIntoGrid(FormToolkit toolkit, Composite parent,
-			int nColumns) {
-		assertEnoughColumns(nColumns);
-
-		Control requiredLabel = getRequiredLabelControl(toolkit, parent);
-		requiredLabel.setLayoutData(gridDataForLabel(1));
-
-		Control label = getLabelControl(toolkit, parent);
-		label.setLayoutData(gridDataForLabel(1));
-
-		_group = getGroup(toolkit, parent);
-		_group.setLayoutData(gridDataForGroup(nColumns - 2));
-
-		return new Control[] { requiredLabel, label, _group };
-	}
-
-	/*
-	 * @see DialogField#getNumberOfControls
-	 */
-	public int getNumberOfControls() {
-		return 3;
-	}
-
-	/**
-	 * @param span
-	 * @return the grid data
-	 */
-	protected static GridData gridDataForGroup(int span) {
-		GridData gd = new GridData();
-		gd.horizontalAlignment = GridData.FILL;
-		gd.grabExcessHorizontalSpace = false;
-		gd.horizontalSpan = span;
-		return gd;
-	}
-
-	// ------- focus methods
-
-	/*
-	 * @see DialogField#setFocus
-	 */
-	public boolean setFocus() {
-		if (isOkToUse(_group)) {
-			_group.setFocus();
-		}
-		return true;
-	}
-
-	// ------- ui creation
-
-	/**
-	 * @param toolkit
-	 * @param parent
-	 * @return the group composite
-	 */
-	public Composite getGroup(FormToolkit toolkit, Composite parent) {
-		if (_group == null || _group.isDisposed()) {
-			assertCompositeNotNull(parent);
-			if (toolkit != null) {
-				_group = toolkit.createComposite(parent);
-			} else {
-				_group = new Composite(parent, SWT.NONE);
-			}
-			RowLayout layout = new RowLayout();
-			layout.marginBottom = 0;
-			_group.setLayout(layout);
-			for (int i = 0; i < _items.length; i++) {
-				if (toolkit != null) {
-					_button[i] = toolkit.createButton(_group, _items[i],
-							SWT.RADIO);
-				} else {
-					_button[i] = new Button(_group, SWT.RADIO);
-					_button[i].setText(_items[i]);
-				}
-				_button[i].setData(INDEXKEY, new Integer(i));
-				_button[i].addSelectionListener(new SelectionAdapter() {
-					public void widgetSelected(SelectionEvent e) {
-						if (_fireEvent) {
-							_selectIndex = ((Integer) e.widget
-									.getData(INDEXKEY)).intValue();
-							// FIXME: seemed will fire widgetSelected twice, one
-							// for the deselect one,
-							// one for the newly selected one. Need investigate.
-							if (((Button) e.widget).getSelection()) {
-								dialogFieldChangedAndApplied();
-							}
-						}
-					}
-
-				});
-			}
-		}
-		return _group;
-	}
-
-	// ------ enable / disable management
-
-	/*
-	 * @see DialogField#updateEnableState
-	 */
-	protected void updateEnableState() {
-		super.updateEnableState();
-		if (isOkToUse(_group)) {
-			_group.setEnabled(isEnabled());
-		}
-	}
-
-	// ------ text access
-
-	/**
-	 * Sets the text. Triggers a dialog-changed event.
-	 * @param index 
-	 */
-	public void setSelectedIndex(int index) {
-		_selectIndex = index;
-		if (isOkToUse(_group)) {
-			if (_selectIndex >= 0 && _selectIndex < _items.length) {
-				_button[_selectIndex].setSelection(true);
-			} else {
-				for (int i = 0; i < _items.length; i++) {
-					if (_button[i].getSelection()) {
-						_button[i].setSelection(false);
-					}
-				}
-			}
-		}
-		dialogFieldChangedAndApplied();
-	}
-
-	/**
-	 * Sets the text without triggering a dialog-changed event.
-	 * @param index 
-	 */
-	public void setSelectedIndexWithoutUpdate(int index) {
-		_selectIndex = index;
-		if (isOkToUse(_group)) {
-			_fireEvent = false;
-			if (_selectIndex >= 0 && _selectIndex < _items.length) {
-				_button[_selectIndex].setSelection(true);
-			} else {
-				for (int i = 0; i < _items.length; i++) {
-					if (_button[i].getSelection()) {
-						_button[i].setSelection(false);
-					}
-				}
-			}
-			_fireEvent = true;
-		}
-	}
-
-	/**
-	 * @return the index selected
-	 */
-	public int getSelectedIndex() {
-		return _selectIndex;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.jsf.common.ui.internal.dialogfield.DialogField#handleGrabHorizontal()
-	 */
-	public void handleGrabHorizontal() {
-		LayoutUtil.setGrabHorizontal(this._group, true);
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/ResourceButtonDialogField.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/ResourceButtonDialogField.java
deleted file mode 100644
index 8ab30f0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/ResourceButtonDialogField.java
+++ /dev/null
@@ -1,231 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IFolder;
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.jface.window.Window;
-import org.eclipse.jst.jsf.common.ui.JSFUICommonPlugin;
-import org.eclipse.jst.jsf.common.ui.internal.dialogs.CommonResourceDialog;
-import org.eclipse.jst.jsf.common.ui.internal.utils.PathUtil;
-import org.eclipse.jst.jsf.common.ui.internal.utils.WebrootUtil;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.widgets.Shell;
-
-/**
- * This class provides a common resource choice DialogFiled. You must set a
- * no-null IProject instance to enable it working. You should give it a suffix
- * list if you want to choose files ended with specific file extensions. The
- * selection result will be a relative path based on the _referredFile's value
- * if it is set, or else based on the _project path.
- * 
- * The usage: Shell shell = new Shell(); IProject project = getProject();
- * ResourceButtonDialogField localeField = new
- * ResourceButtonDialogField(project);
- * localeField.setResourceDescription("image"); localeField.setSuffixs(new
- * String[]{"bmp","jpg","gif"});
- * localeField.setReferredFile(StructuredModelUtil.getFileFor(_element.getModel()));
- * 
- * @author mengbo
- */
-public class ResourceButtonDialogField extends StringButtonDialogField {
-	private IProject _project;
-
-	private String[] _suffixs;
-
-	private String _resourceDescription;
-
-	private IFile _referredFile;
-
-	private boolean _isWebPath = false;
-
-	private IFolder _folder;
-
-	private String _separator = ""; //$NON-NLS-1$
-
-	/**
-	 * @param project
-	 */
-	public ResourceButtonDialogField(IProject project) {
-		this(null, project);
-		setStringButtonAdapter(new IStringButtonAdapter() {
-			public void changeControlPressed(DialogField field) {
-				String oldValue = getText();
-				String newValue = browseButtonPressed();
-				if (newValue != null && !newValue.equals(oldValue)) {
-					setText(newValue);
-				}
-			}
-		});
-	}
-
-	/**
-	 * @param adapter
-	 * @param project
-	 */
-	public ResourceButtonDialogField(IStringButtonAdapter adapter,
-			IProject project) {
-		super(adapter);
-		this._project = project;
-	}
-
-	/**
-	 * @return the string
-	 */
-	protected String browseButtonPressed() {
-		Shell shell = getShell();
-		CommonResourceDialog dialog = null;
-		int style = "".equals(_separator) ? SWT.NONE : SWT.MULTI | SWT.H_SCROLL //$NON-NLS-1$
-				| SWT.V_SCROLL;
-		if (_folder != null) {
-			dialog = new CommonResourceDialog(shell, _folder.getProject(), style);
-		} else {
-			dialog = new CommonResourceDialog(shell, _project, style);
-		}
-		dialog.setTitle(JSFUICommonPlugin
-				.getResourceString("DialogField.ResourceButton.SelectFile"));//$NON-NLS-1$
-		dialog.setSuffixs(_suffixs);
-		dialog.setResourceDescription(_resourceDescription);
-
-		if (dialog.open() == Window.OK) {
-			Object[] result = dialog.getResult();
-			StringBuffer buffer = new StringBuffer();
-			for (int i = 0; i < result.length; i++) {
-				String newValue = null;
-				IPath path = ((IFile) result[i]).getLocation();
-
-				IPath referredPath = null;
-				if (_referredFile != null) {
-					referredPath = _referredFile.getLocation();
-				} else {
-					referredPath = _project.getLocation();
-				}
-				if (this._isWebPath) {
-					IFile selectedFile = ((IFile) result[i]);
-					newValue = WebrootUtil.getWebPath(selectedFile
-							.getFullPath());
-				} else {
-					newValue = PathUtil.convertToRelativePath(path.toString(),
-							referredPath.toString());
-				}
-				buffer.append(newValue);
-				buffer.append(_separator);
-			}
-			if (buffer.length() > 0) {
-				return buffer.substring(0, buffer.length()
-						- _separator.length());
-			}
-
-		}
-		return null;
-	}
-
-	/**
-	 * @return Returns the project.
-	 */
-	public IProject getProject() {
-		return _project;
-	}
-
-	/**
-	 * @param project
-	 *            The project to set.
-	 */
-	public void setProject(IProject project) {
-		this._project = project;
-	}
-
-	/**
-	 * @return Returns the relative folder.
-	 */
-	public IFolder getFolder() {
-		return _folder;
-	}
-
-	/**
-	 * @param folder
-	 *            The relative folder to set.
-	 */
-	public void setFolder(IFolder folder) {
-		this._folder = folder;
-	}
-
-	/**
-	 * @return Returns the referredFile.
-	 */
-	public IFile getReferredFile() {
-		return _referredFile;
-	}
-
-	/**
-	 * @param referredFile
-	 *            The referredFile to set.
-	 */
-	public void setReferredFile(IFile referredFile) {
-		this._referredFile = referredFile;
-	}
-
-	/**
-	 * @return Returns the resourceDescription.
-	 */
-	public String getResourceDescription() {
-		return _resourceDescription;
-	}
-
-	/**
-	 * @param resourceDescription
-	 *            The resourceDescription to set.
-	 */
-	public void setResourceDescription(String resourceDescription) {
-		this._resourceDescription = resourceDescription;
-	}
-
-	/**
-	 * @return Returns the suffixs.
-	 */
-	public String[] getSuffixs() {
-		return _suffixs;
-	}
-
-	/**
-	 * @param suffixs
-	 *            The suffixs to set.
-	 */
-	public void setSuffixs(String[] suffixs) {
-		this._suffixs = suffixs;
-	}
-
-	/**
-	 * set some special path to web path instead of relative path
-	 * 
-	 * @param isWebPath
-	 */
-	public void setWebPath(boolean isWebPath) {
-		this._isWebPath = isWebPath;
-	}
-
-	/**
-	 * @return the separator string
-	 */
-	public String getSeparator() {
-		return _separator;
-	}
-
-	/**
-	 * @param separator
-	 */
-	public void setSeparator(String separator) {
-		this._separator = separator;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/Separator.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/Separator.java
deleted file mode 100644
index f54722a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/Separator.java
+++ /dev/null
@@ -1,128 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Label;
-import org.eclipse.ui.forms.widgets.FormToolkit;
-
-/**
- * Dialog field describing a separator.
- */
-public class Separator extends DialogFieldBase {
-
-	private Label _separator;
-
-	private int _style;
-
-	/**
-	 * Default constructor
-	 */
-	public Separator() {
-		this(SWT.NONE);
-	}
-
-	/**
-	 * @param style
-	 *            of the separator. See <code>Label</code> for possible
-	 *            styles.
-	 */
-	public Separator(int style) {
-		_style = style;
-	}
-
-	// ------- layout helpers
-
-	/**
-	 * Creates the separator and fills it in a MGridLayout.
-	 * @param toolkit 
-	 * @param parent 
-	 * @param nColumns 
-	 * 
-	 * @param height
-	 *            The heigth of the separator
-	 * @return the controls or empty array
-	 */
-	public Control[] doFillIntoGrid(FormToolkit toolkit, Composite parent,
-			int nColumns, int height) {
-		assertEnoughColumns(nColumns);
-
-		Control separator = getSeparator(toolkit, parent);
-		separator.setLayoutData(gridDataForSeperator(nColumns, height));
-
-		return new Control[] { separator };
-	}
-
-	/*
-	 * @see DialogField#doFillIntoGrid
-	 */
-	public Control[] doFillIntoGrid(FormToolkit toolkit, Composite parent,
-			int nColumns) {
-		return doFillIntoGrid(toolkit, parent, nColumns, 4);
-	}
-
-	/*
-	 * @see DialogField#getNumberOfControls
-	 */
-	public int getNumberOfControls() {
-		return 1;
-	}
-
-	/**
-	 * @param span
-	 * @param height
-	 * @return the grid data
-	 */
-	protected static GridData gridDataForSeperator(int span, int height) {
-		GridData gd = new GridData();
-		gd.horizontalAlignment = GridData.FILL;
-		gd.verticalAlignment = GridData.BEGINNING;
-		gd.heightHint = height;
-		gd.horizontalSpan = span;
-		return gd;
-	}
-
-	// ------- ui creation
-
-	/**
-	 * Creates or returns the created separator.
-	 * @param toolkit 
-	 * 
-	 * @param parent
-	 *            The parent composite or <code>null</code> if the widget has
-	 *            already been created.
-	 * @return  the separator
-	 */
-	private Control getSeparator(FormToolkit toolkit, Composite parent) {
-		if (_separator == null || _separator.isDisposed()) {
-			assertCompositeNotNull(parent);
-			if (toolkit != null) {
-				_separator = toolkit.createSeparator(parent, _style);
-			} else {
-				_separator = new Label(parent, _style);
-			}
-		}
-		return _separator;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.jsf.common.ui.internal.dialogfield.DialogField#handleGrabHorizontal()
-	 */
-	public void handleGrabHorizontal() {
-		// do nothing.
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/SourceFolderButtonDialogField.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/SourceFolderButtonDialogField.java
deleted file mode 100644
index 420a950..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/SourceFolderButtonDialogField.java
+++ /dev/null
@@ -1,340 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.resources.ResourcesPlugin;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.jdt.core.IJavaElement;
-import org.eclipse.jdt.core.IJavaModel;
-import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.core.IPackageFragmentRoot;
-import org.eclipse.jdt.core.JavaCore;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jdt.ui.JavaElementComparator;
-import org.eclipse.jdt.ui.JavaElementLabelProvider;
-import org.eclipse.jdt.ui.StandardJavaElementContentProvider;
-import org.eclipse.jface.viewers.ILabelProvider;
-import org.eclipse.jface.viewers.Viewer;
-import org.eclipse.jface.viewers.ViewerFilter;
-import org.eclipse.jface.window.Window;
-import org.eclipse.jst.jsf.common.ui.JSFUICommonPlugin;
-import org.eclipse.jst.jsf.common.ui.internal.logging.Logger;
-import org.eclipse.ui.dialogs.ElementTreeSelectionDialog;
-
-/**
- * This class provides a source folder selection DialogFiled. There are two
- * conditions: 1. If you set the IProject instance, the source folder selection
- * will only be limited in the specified project 2. If you set null, the source
- * folder selection is allowed in all workspaces
- * 
- * 
- * @author mengbo
- * @version 1.5
- */
-public class SourceFolderButtonDialogField extends StringButtonDialogField {
-	/** Create the logger for this class */
-	private static Logger _log = JSFUICommonPlugin
-			.getLogger(SourceFolderButtonDialogField.class);
-
-	/**
-	 * package fragment root corresponding to the input type (can be null)
-	 */
-	private IPackageFragmentRoot _fCurrRoot;
-
-	private IProject _project;
-
-	/**
-	 * @param project 
-	 */
-	public SourceFolderButtonDialogField(IProject project) {
-		super(null);
-
-		_project = project;
-
-		setLabelText(DialogFieldResources.getInstance().getString(
-				"SourceFolderButtonDialogField.container.label")); //$NON-NLS-1$
-
-		setButtonLabel(DialogFieldResources.getInstance().getString(
-				"SourceFolderButtonDialogField.container.button")); //$NON-NLS-1$
-
-		setStringButtonAdapter(new IStringButtonAdapter() {
-			public void changeControlPressed(DialogField field) {
-				containerChangeControlPressed(field);
-			}
-
-		});
-	}
-
-	/**
-	 * @return Returns the project.
-	 */
-	public IProject getProject() {
-		return _project;
-	}
-
-	/**
-	 * @param project
-	 *            The project to set.
-	 */
-	public void setProject(IProject project) {
-		this._project = project;
-	}
-
-	/**
-	 * @param field
-	 */
-	protected void containerChangeControlPressed(DialogField field) {
-		// take the current jproject as init element of the dialog
-		IPackageFragmentRoot root = getPackageFragmentRoot();
-		root = chooseSourceContainer(root);
-		if (root != null) {
-			setPackageFragmentRoot(root, true);
-		}
-	}
-
-	/**
-	 * Sets the current source folder (model and text field) to the given
-	 * package fragment root.
-	 * 
-	 * @param root
-	 *            The new root.
-	 * @param canBeModified
-	 *            if <code>false</code> the source folder field can not be
-	 *            changed by the user. If <code>true</code> the field is
-	 *            editable
-	 */
-	public void setPackageFragmentRoot(IPackageFragmentRoot root,
-			boolean canBeModified) {
-		_fCurrRoot = root;
-		String str = (root == null) ? "" : root.getPath().makeRelative().toString(); //$NON-NLS-1$
-		setText(str);
-		setEnabled(canBeModified);
-	}
-
-	/**
-	 * Returns the <code>IPackageFragmentRoot</code> that corresponds to the
-	 * current value of the source folder field.
-	 * 
-	 * @return the IPackageFragmentRoot or <code>null</code> if the current
-	 *         source folder value is not a valid package fragment root
-	 * 
-	 */
-	public IPackageFragmentRoot getPackageFragmentRoot() {
-		return _fCurrRoot;
-	}
-
-	/**
-	 * Returns the current text of source folder text field.
-	 * 
-	 * @return the text of the source folder text field
-	 */
-	public String getPackageFragmentRootText() {
-		return getText();
-	}
-
-	/**
-	 * choose source container dialog
-	 * 
-	 * @param initElement
-	 * @return
-	 */
-	private IPackageFragmentRoot chooseSourceContainer(IJavaElement initElement) {
-		Class[] acceptedClasses = new Class[] { IPackageFragmentRoot.class,
-				IJavaProject.class, };
-
-		TypedElementSelectionValidator validator = new TypedElementSelectionValidator(
-				acceptedClasses, false) {
-            // TODO: never used
-//			public boolean isSelectedValid(Object element) {
-//				try {
-//					if (element instanceof IJavaProject) {
-//						IJavaProject jproject = (IJavaProject) element;
-//						IPath path = jproject.getProject().getFullPath();
-//						return (jproject.findPackageFragmentRoot(path) != null);
-//					} else if (element instanceof IPackageFragmentRoot) {
-//						return (((IPackageFragmentRoot) element).getKind() == IPackageFragmentRoot.K_SOURCE);
-//					}
-//					return true;
-//				} catch (JavaModelException e) {
-//					_log.error("JavaModelException"); // just log, no ui in
-//					// validation
-//				}
-//				return false;
-//			}
-		};
-
-		acceptedClasses = new Class[] { IJavaModel.class,
-				IPackageFragmentRoot.class, IJavaProject.class, };
-		ViewerFilter filter = new TypedViewerFilter(acceptedClasses) {
-			public boolean select(Viewer viewer, Object parent, Object element) {
-				if (element instanceof IPackageFragmentRoot) {
-					try {
-						return (((IPackageFragmentRoot) element).getKind() == IPackageFragmentRoot.K_SOURCE);
-					} catch (JavaModelException e) {
-						_log.error(e); // just log, no ui
-						// in validation
-						return false;
-					}
-				}
-				return super.select(viewer, parent, element);
-			}
-		};
-
-		StandardJavaElementContentProvider provider = new StandardJavaElementContentProvider();
-		ILabelProvider labelProvider = new JavaElementLabelProvider(
-				JavaElementLabelProvider.SHOW_DEFAULT);
-		ElementTreeSelectionDialog dialog = new ElementTreeSelectionDialog(
-				getShell(), labelProvider, provider);
-		dialog.setValidator(validator);
-		dialog.setComparator(new JavaElementComparator());
-		// HibernateWizardPage.ChooseSourceContainerDialog.Title = Folder
-		// Selection
-		dialog
-				.setTitle(DialogFieldResources
-						.getInstance()
-						.getString(
-								"SourceFolderButtonDialogField.ChooseSourceContainerDialog.Title")); //$NON-NLS-1$
-		// HibernateWizardPage.ChooseSourceContainerDialog.Description = Choose
-		// a folder:
-		dialog
-				.setMessage(DialogFieldResources
-						.getInstance()
-						.getString(
-								"SourceFolderButtonDialogField.ChooseSourceContainerDialog.Description")); //$NON-NLS-1$
-		dialog.addFilter(filter);
-		if (_project != null) {
-			dialog.setInput(JavaCore.create(_project));
-		} else {
-			dialog.setInput(JavaCore.create(ResourcesPlugin.getWorkspace()
-					.getRoot()));
-		}
-		dialog.setInitialSelection(initElement);
-
-		if (dialog.open() == Window.OK) {
-			Object element = dialog.getFirstResult();
-			if (element instanceof IJavaProject) {
-				IJavaProject jproject = (IJavaProject) element;
-				return jproject.getPackageFragmentRoot(jproject.getProject());
-			} else if (element instanceof IPackageFragmentRoot) {
-				return (IPackageFragmentRoot) element;
-			}
-			return null;
-		}
-		return null;
-	}
-
-	/**
-	 * This method updates the model and returns an error status. The underlying
-	 * model is only valid if the returned status is OK.
-	 * 
-	 * @return the model's error status
-	 */
-	public IStatus getChangedStatus() {
-		StatusInfo status = new StatusInfo();
-
-		_fCurrRoot = null;
-		String str = getPackageFragmentRootText();
-		if (str.length() == 0) {
-			// SourceFolderButtonDialogField.error.EnterContainerName = Folder
-			// name is empty.
-			status.setError(DialogFieldResources.getInstance().getString(
-					"SourceFolderButtonDialogField.error.EnterContainerName")); //$NON-NLS-1$
-			return status;
-		}
-		IPath path = new Path(str);
-		IResource res = ResourcesPlugin.getWorkspace().getRoot().findMember(
-				path);
-		if (res != null) {
-			int resType = res.getType();
-			if (resType == IResource.PROJECT || resType == IResource.FOLDER) {
-				IProject proj = res.getProject();
-				if (!proj.isOpen()) {
-					status
-							.setError(DialogFieldResources
-									.getInstance()
-									.getString(
-											"SourceFolderButtonDialogField.error.ProjectClosed", proj.getFullPath().toString())); //$NON-NLS-1$
-					return status;
-				}
-				if (_project != null && proj != _project) {
-					// HibernateWizardPage.error.NotSameProject = The project
-					// should be \''{0}\''.
-					status
-							.setError(DialogFieldResources
-									.getInstance()
-									.getString(
-											"SourceFolderButtonDialogField.error.NotSameProject", _project.getName())); //$NON-NLS-1$
-					return status;
-				}
-				IJavaProject jproject = JavaCore.create(proj);
-				_fCurrRoot = jproject.getPackageFragmentRoot(res);
-				if (res.exists()) {
-					try {
-						if (!proj.hasNature(JavaCore.NATURE_ID)) {
-							if (resType == IResource.PROJECT) {
-								status
-										.setError(DialogFieldResources
-												.getInstance()
-												.getString(
-														"SourceFolderButtonDialogField.warning.NotAJavaProject", proj.getName())); //$NON-NLS-1$
-							} else {
-								status
-										.setWarning(DialogFieldResources
-												.getInstance()
-												.getString(
-														"SourceFolderButtonDialogField.warning.NotInAJavaProject", proj.getName())); //$NON-NLS-1$
-							}
-							return status;
-						}
-					} catch (CoreException e) {
-						status
-								.setWarning(DialogFieldResources
-										.getInstance()
-										.getString(
-												"SourceFolderButtonDialogField.warning.NotAJavaProject", proj.getName())); //$NON-NLS-1$
-					}
-					if (!jproject.isOnClasspath(_fCurrRoot)) {
-						status
-								.setWarning(DialogFieldResources
-										.getInstance()
-										.getString(
-												"SourceFolderButtonDialogField.warning.NotOnClassPath", str)); //$NON-NLS-1$
-					}
-					if (_fCurrRoot.isArchive()) {
-						status
-								.setError(DialogFieldResources
-										.getInstance()
-										.getString(
-												"SourceFolderButtonDialogField.error.ContainerIsBinary", str)); //$NON-NLS-1$
-						return status;
-					}
-				}
-				return status;
-			}
-            status.setError(DialogFieldResources.getInstance().getString(
-                    "SourceFolderButtonDialogField.error.NotAFolder", str)); //$NON-NLS-1$
-            return status;
-		}
-        status
-                 .setError(DialogFieldResources
-                        .getInstance()
-                        .getString(
-                                "SourceFolderButtonDialogField.error.ContainerDoesNotExist", str)); //$NON-NLS-1$
-        return status;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/StatusInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/StatusInfo.java
deleted file mode 100644
index 8a8c9b7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/StatusInfo.java
+++ /dev/null
@@ -1,198 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import org.eclipse.core.runtime.Assert;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.jst.jsf.common.ui.JSFUICommonPlugin;
-
-/**
- * A settable IStatus. Can be an error, warning, info or ok. For error, info and
- * warning states, a message describes the problem.
- * 
- * TODO: couldn't have sub-classed Status?
- * 
- * @author mengbo
- * @version 1.5
- */
-/*package*/ class StatusInfo implements IStatus {
-
-	/**
-	 * a default status info for IStatus.OK
-	 */
-	public static final IStatus OK_STATUS = new StatusInfo();
-
-	private String fStatusMessage;
-
-	private int fSeverity;
-
-	/**
-	 * Creates a status set to OK (no message)
-	 */
-	public StatusInfo() {
-		this(OK, null);
-	}
-
-	/**
-	 * Creates a status .
-	 * 
-	 * @param severity
-	 *            The status severity: ERROR, WARNING, INFO and OK.
-	 * @param message
-	 *            The message of the status. Applies only for ERROR, WARNING and
-	 *            INFO.
-	 */
-	public StatusInfo(int severity, String message) {
-		fStatusMessage = message;
-		fSeverity = severity;
-	}
-
-	/**
-	 * Returns if the status' severity is OK.
-	 */
-	public boolean isOK() {
-		return fSeverity == IStatus.OK;
-	}
-
-	/**
-	 * Returns if the status' severity is WARNING.
-	 * @return true if severity is IStatus.WARNING
-	 */
-	public boolean isWarning() {
-		return fSeverity == IStatus.WARNING;
-	}
-
-	/**
-	 * Returns if the status' severity is INFO.
-	 * @return true if severity is INFO
-	 */
-	public boolean isInfo() {
-		return fSeverity == IStatus.INFO;
-	}
-
-	/**
-	 * Returns if the status' severity is ERROR.
-	 * @return true if severity is error
-	 */
-	public boolean isError() {
-		return fSeverity == IStatus.ERROR;
-	}
-
-	/**
-	 * @see IStatus#getMessage
-	 */
-	public String getMessage() {
-		return fStatusMessage;
-	}
-
-	/**
-	 * Sets the status to ERROR.
-	 * 
-	 * @param errorMessage
-	 *            The error message (can be empty, but not null)
-	 */
-	public void setError(String errorMessage) {
-		Assert.isNotNull(errorMessage);
-		fStatusMessage = errorMessage;
-		fSeverity = IStatus.ERROR;
-	}
-
-	/**
-	 * Sets the status to WARNING.
-	 * 
-	 * @param warningMessage
-	 *            The warning message (can be empty, but not null)
-	 */
-	public void setWarning(String warningMessage) {
-		Assert.isNotNull(warningMessage);
-		fStatusMessage = warningMessage;
-		fSeverity = IStatus.WARNING;
-	}
-
-	/**
-	 * Sets the status to INFO.
-	 * 
-	 * @param infoMessage
-	 *            The info message (can be empty, but not null)
-	 */
-	public void setInfo(String infoMessage) {
-		Assert.isNotNull(infoMessage);
-		fStatusMessage = infoMessage;
-		fSeverity = IStatus.INFO;
-	}
-
-	/**
-	 * Sets the status to OK.
-	 */
-	public void setOK() {
-		fStatusMessage = null;
-		fSeverity = IStatus.OK;
-	}
-
-	/*
-	 * @see IStatus#matches(int)
-	 */
-	public boolean matches(int severityMask) {
-		return (fSeverity & severityMask) != 0;
-	}
-
-	/**
-	 * Returns always <code>false</code>.
-	 * 
-	 * @see IStatus#isMultiStatus()
-	 */
-	public boolean isMultiStatus() {
-		return false;
-	}
-
-	/*
-	 * @see IStatus#getSeverity()
-	 */
-	public int getSeverity() {
-		return fSeverity;
-	}
-
-	/*
-	 * @see IStatus#getPlugin()
-	 */
-	public String getPlugin() {
-		return JSFUICommonPlugin.getPluginId();
-	}
-
-	/**
-	 * Returns always <code>null</code>.
-	 * 
-	 * @see IStatus#getException()
-	 */
-	public Throwable getException() {
-		return null;
-	}
-
-	/**
-	 * Returns always the error severity.
-	 * 
-	 * @see IStatus#getCode()
-	 */
-	public int getCode() {
-		return fSeverity;
-	}
-
-	/**
-	 * Returns always <code>null</code>.
-	 * 
-	 * @see IStatus#getChildren()
-	 */
-	public IStatus[] getChildren() {
-		return new IStatus[0];
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/StatusUtil.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/StatusUtil.java
deleted file mode 100644
index 22fe6d8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/StatusUtil.java
+++ /dev/null
@@ -1,114 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.jface.dialogs.DialogPage;
-
-/**
- * copied from org.eclipse.jdt.internal.dialogs. Enhanced to support null status
- * as parameter
- * 
- * A utility class to work with IStatus.
- */
-public class StatusUtil {
-
-	/**
-	 * Compares two instances of <code>IStatus</code>. The more severe is
-	 * returned: An error is more severe than a warning, and a warning is more
-	 * severe than ok. If the two stati have the same severity, the second is
-	 * returned.
-	 * @param s1 
-	 * @param s2 
-	 * 
-	 * @return Could be null.
-	 */
-	public static IStatus getMoreSevere(IStatus s1, IStatus s2) {
-		if (s1 == null && s2 == null) {
-			return null;
-		} else if (s1 == null) {
-			return s2;
-		} else if (s2 == null) {
-			return s1;
-		} else if (s1.getSeverity() > s2.getSeverity()) {
-			return s1;
-		} else {
-			return s2;
-		}
-	}
-
-	/**
-	 * Finds the most severe status from a array of stati. An error is more
-	 * severe than a warning, and a warning is more severe than ok.
-	 * @param status 
-	 * 
-	 * @return could be null
-	 */
-	public static IStatus getMostSevere(IStatus[] status) {
-		if (status == null)
-			return null;
-		IStatus max = null;
-		for (int i = 0; i < status.length; i++) {
-			IStatus curr = status[i];
-			if (curr == null)
-				continue;
-
-			if (curr.matches(IStatus.ERROR)) {
-				return curr;
-			}
-			if (max == null || curr.getSeverity() > max.getSeverity()) {
-				max = curr;
-			}
-		}
-		if (max != null)
-        {
-			return max;
-        }
-
-        return null;
-	}
-
-	/**
-	 * Applies the status to the status line of a dialog page.
-	 * @param page 
-	 * @param status 
-	 */
-	public static void applyToStatusLine(DialogPage page, IStatus status) {
-		if (status == null) {
-			page.setMessage(null);
-			page.setErrorMessage(null);
-		} else {
-			String message = status.getMessage();
-			switch (status.getSeverity()) {
-			case IStatus.OK:
-				page.setMessage(message, DialogPage.NONE);
-				page.setErrorMessage(null);
-				break;
-			case IStatus.WARNING:
-				page.setMessage(message, DialogPage.WARNING);
-				page.setErrorMessage(null);
-				break;
-			case IStatus.INFO:
-				page.setMessage(message, DialogPage.INFORMATION);
-				page.setErrorMessage(null);
-				break;
-			default:
-				if (message.length() == 0) {
-					message = null;
-				}
-				page.setMessage(null);
-				page.setErrorMessage(message);
-				break;
-			}
-		}
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/StringButtonDialogField.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/StringButtonDialogField.java
deleted file mode 100644
index eebc9e5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/StringButtonDialogField.java
+++ /dev/null
@@ -1,186 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import org.eclipse.jst.jsf.common.ui.JSFUICommonPlugin;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.SelectionEvent;
-import org.eclipse.swt.events.SelectionListener;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.widgets.Button;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Text;
-import org.eclipse.ui.forms.widgets.FormToolkit;
-
-/**
- * Dialog field containing a label, text control and a button control.
- */
-public class StringButtonDialogField extends StringDialogField {
-	private Button _browseButton;
-
-	private String _browseButtonLabel;
-
-	private IStringButtonAdapter _stringButtonAdapter;
-
-	private boolean _buttonEnabled;
-
-	/**
-	 * @param adapter
-	 */
-	public StringButtonDialogField(IStringButtonAdapter adapter) {
-		_stringButtonAdapter = adapter;
-		_browseButtonLabel = JSFUICommonPlugin
-				.getResourceString("DialogField.Browse"); //$NON-NLS-1$
-		_buttonEnabled = true;
-	}
-
-	/**
-	 * Sets the label of the button.
-	 * @param label 
-	 */
-	public void setButtonLabel(String label) {
-		_browseButtonLabel = label;
-	}
-
-	// ------ adapter communication
-
-	/**
-	 * Programmatical pressing of the button
-	 */
-	public void changeControlPressed() {
-		_stringButtonAdapter.changeControlPressed(this);
-	}
-
-	// ------- layout helpers
-
-	/*
-	 * @see DialogField#doFillIntoGrid
-	 */
-	public Control[] doFillIntoGrid(FormToolkit toolkit, Composite parent,
-			int nColumns) {
-		assertEnoughColumns(nColumns);
-
-		Control requiredLabel = getRequiredLabelControl(toolkit, parent);
-		requiredLabel.setLayoutData(gridDataForLabel(1));
-
-		Control label = getLabelControl(toolkit, parent);
-		label.setLayoutData(gridDataForLabel(1));
-
-		Text text = getTextControl(toolkit, parent);
-		text.setLayoutData(gridDataForText(nColumns - 3));
-		Button button = getChangeControl(toolkit, parent);
-		button.setLayoutData(gridDataForButton(toolkit, button, text, 1));
-
-		return new Control[] { requiredLabel, label, text, button };
-	}
-
-	/*
-	 * @see DialogField#getNumberOfControls
-	 */
-	public int getNumberOfControls() {
-		return 4;
-	}
-
-	/**
-	 * @param toolkit
-	 * @param button
-	 * @param text
-	 * @param span
-	 * @return the grid data for the button
-	 */
-	protected static GridData gridDataForButton(FormToolkit toolkit,
-			Button button, Text text, int span) {
-		GridData gd = new GridData();
-		gd.horizontalAlignment = GridData.FILL;
-		gd.grabExcessHorizontalSpace = false;
-		gd.horizontalSpan = span;
-		// gd.heightHint = SWTUtil.getButtonHeightHint(button);
-		gd.widthHint = LayoutUtil.getButtonWidthHint(button);
-		gd.heightHint = LayoutUtil.getButtonHeightHint(toolkit, text);
-		return gd;
-	}
-
-	// ------- ui creation
-
-	/**
-	 * Creates or returns the created buttom widget.
-	 * @param toolkit 
-	 * 
-	 * @param parent
-	 *            The parent composite or <code>null</code> if the widget has
-	 *            already been created.
-	 * @return the button
-	 */
-	public Button getChangeControl(FormToolkit toolkit, Composite parent) {
-		if (_browseButton == null || _browseButton.isDisposed()) {
-			assertCompositeNotNull(parent);
-			if (toolkit != null) {
-				_browseButton = toolkit.createButton(parent,
-						_browseButtonLabel, SWT.PUSH);
-			} else {
-				_browseButton = new Button(parent, SWT.PUSH);
-				_browseButton.setText(_browseButtonLabel);
-			}
-			_browseButton.setEnabled(isEnabled() && _buttonEnabled);
-			_browseButton.addSelectionListener(new SelectionListener() {
-				public void widgetDefaultSelected(SelectionEvent e) {
-					changeControlPressed();
-				}
-
-				public void widgetSelected(SelectionEvent e) {
-					changeControlPressed();
-				}
-			});
-
-		}
-		return _browseButton;
-	}
-
-	// ------ enable / disable management
-
-	/**
-	 * Sets the enable state of the button.
-	 * @param enable 
-	 */
-	public void enableButton(boolean enable) {
-		if (isOkToUse(_browseButton)) {
-			_browseButton.setEnabled(isEnabled() && enable);
-		}
-		_buttonEnabled = enable;
-	}
-
-	/*
-	 * @see DialogField#updateEnableState
-	 */
-	protected void updateEnableState() {
-		super.updateEnableState();
-		if (isOkToUse(_browseButton)) {
-			_browseButton.setEnabled(isEnabled() && _buttonEnabled);
-		}
-	}
-
-	/**
-	 * @return Returns the _stringButtonAdapter.
-	 */
-	public IStringButtonAdapter getStringButtonAdapter() {
-		return _stringButtonAdapter;
-	}
-
-	/**
-	 * @param buttonAdapter
-	 *            The _stringButtonAdapter to set.
-	 */
-	public void setStringButtonAdapter(IStringButtonAdapter buttonAdapter) {
-		_stringButtonAdapter = buttonAdapter;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/StringDialogField.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/StringDialogField.java
deleted file mode 100644
index bf334a5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/StringDialogField.java
+++ /dev/null
@@ -1,291 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.FocusAdapter;
-import org.eclipse.swt.events.FocusEvent;
-import org.eclipse.swt.events.KeyAdapter;
-import org.eclipse.swt.events.KeyEvent;
-import org.eclipse.swt.events.ModifyEvent;
-import org.eclipse.swt.events.ModifyListener;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Text;
-import org.eclipse.ui.forms.widgets.FormToolkit;
-
-/**
- * Dialog field containing a label and a text control.
- */
-public class StringDialogField extends DialogFieldBase implements
-		ISupportTextValue {
-	final static private int TEXT_WIDTH_HINT = 10;
-
-	private String _text;
-
-	private Text _textControl;
-
-	private ModifyListener _modifyListener;
-
-	private int _numRows;
-
-	/**
-	 * whether there is change in the UI but not fire applied event yet.
-	 */
-	private boolean _pending = false;
-
-	/**
-	 * default constructor
-	 * numRows == 1
-	 */
-	public StringDialogField() {
-		this(1);
-		_text = ""; //$NON-NLS-1$
-	}
-
-	/**
-	 * @param numRows
-	 */
-	public StringDialogField(int numRows) {
-		super();
-		_text = ""; //$NON-NLS-1$
-		_numRows = numRows;
-	}
-
-	// ------- layout helpers
-
-	/*
-	 * @see DialogField#doFillIntoGrid
-	 */
-	public Control[] doFillIntoGrid(FormToolkit kit, Composite parent,
-			int nColumns) {
-		assertEnoughColumns(nColumns);
-
-		Control requiredLabel = getRequiredLabelControl(kit, parent);
-		requiredLabel.setLayoutData(gridDataForLabel(1));
-
-		Control label = getLabelControl(kit, parent);
-		label.setLayoutData(gridDataForLabel(1));
-
-		Text text = getTextControl(kit, parent);
-		int heightHint = -1;
-		if (_numRows > 1) {
-			heightHint = getDialogUnits(parent).getHeight() * _numRows;
-		}
-		text.setLayoutData(gridDataForText(nColumns - 2, heightHint));
-
-		return new Control[] { requiredLabel, label, text };
-	}
-
-	/*
-	 * @see DialogField#getNumberOfControls
-	 */
-	public int getNumberOfControls() {
-		return 3;
-	}
-
-	protected static GridData gridDataForLabel(int span) {
-		GridData gd = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
-		gd.horizontalSpan = span;
-		return gd;
-	}
-
-	/**
-	 * @param span
-	 * @param heightHint
-	 * @return the grid data for text
-	 */
-	protected static GridData gridDataForText(int span, int heightHint) {
-		GridData gd = new GridData();
-		gd.horizontalAlignment = GridData.FILL;
-		gd.grabExcessHorizontalSpace = false;
-		gd.heightHint = heightHint;
-		gd.horizontalSpan = span;
-		gd.widthHint = TEXT_WIDTH_HINT;
-		return gd;
-	}
-
-	/**
-	 * @param span
-	 * @return the grid data for text
-	 */
-	protected static GridData gridDataForText(int span) {
-		GridData gd = gridDataForText(span, -1);
-		return gd;
-	}
-
-	// ------- focus methods
-
-	/*
-	 * @see DialogField#setFocus
-	 */
-	public boolean setFocus() {
-		if (isOkToUse(_textControl)) {
-			_textControl.setFocus();
-			_textControl.setSelection(0, _textControl.getText().length());
-		}
-		return true;
-	}
-
-	// ------- ui creation
-
-	/**
-	 * Creates or returns the created text control.
-	 * @param toolkit 
-	 * 
-	 * @param parent
-	 *            The parent composite or <code>null</code> when the widget
-	 *            has already been created.
-	 * @return the text control
-	 */
-	public Text getTextControl(FormToolkit toolkit, Composite parent) {
-		if (_textControl == null || _textControl.isDisposed()) {
-			assertCompositeNotNull(parent);
-			_modifyListener = new ModifyListener() {
-				public void modifyText(ModifyEvent e) {
-					doModifyText(e);
-				}
-			};
-
-			if (toolkit != null) {
-				if (_numRows <= 1) {
-					_textControl = toolkit.createText(parent, ""); //$NON-NLS-1$
-				} else {
-					_textControl = toolkit.createText(parent, "", SWT.V_SCROLL); //$NON-NLS-1$
-				}
-			} else {
-				if (_numRows <= 1) {
-
-					_textControl = new Text(parent, SWT.SINGLE | SWT.BORDER);
-				} else {
-					_textControl = new Text(parent, SWT.V_SCROLL | SWT.WRAP
-							| SWT.BORDER);
-				}
-			}
-
-			_textControl.setText(_text);
-			_textControl.setFont(parent.getFont());
-			_textControl.addModifyListener(_modifyListener);
-			_textControl.addFocusListener(new FocusAdapter() {
-
-				public void focusLost(FocusEvent e) {
-					doFocusLost(e);
-				}
-
-			});
-			_textControl.addKeyListener(new KeyAdapter() {
-				public void keyReleased(KeyEvent e) {
-					doKeyReleased(e);
-				}
-			});
-
-			_textControl.setEnabled(isEnabled());
-
-			_textControl.setToolTipText(getToolTip());
-		}
-		return _textControl;
-	}
-
-	/**
-	 * @param e
-	 */
-	protected void doKeyReleased(KeyEvent e) {
-		if (e.character == '\r') {
-			// commit value
-			if (_pending) {
-				_pending = false;
-				dialogFieldApplied();
-			}
-		}
-	}
-
-	/**
-	 * @param e
-	 */
-	protected void doFocusLost(FocusEvent e) {
-		if (_pending) {
-			_pending = false;
-			dialogFieldApplied();
-		}
-	}
-
-	/**
-	 * some get changed in the Text. As in <code>setText</code> and
-	 * <code>setTextWithoutUpdate</code> we removed the listener, so this must
-	 * be user typing in the text field.
-	 * 
-	 * @param e
-	 */
-	private void doModifyText(ModifyEvent e) {
-		if (isOkToUse(_textControl)) {
-			_text = _textControl.getText();
-		}
-		_pending = true;
-		dialogFieldChanged();
-	}
-
-	// ------ enable / disable management
-
-	/*
-	 * @see DialogField#updateEnableState
-	 */
-	protected void updateEnableState() {
-		super.updateEnableState();
-		if (isOkToUse(_textControl)) {
-			_textControl.setEnabled(isEnabled());
-		}
-	}
-
-	// ------ text access
-
-	/**
-	 * Gets the text. Can not be <code>null</code>
-	 */
-	public String getText() {
-		return _text;
-	}
-
-	/**
-	 * Sets the text. Triggers a dialog-changed event.
-	 */
-	public void setText(String text) {
-		setTextWithoutUpdate(text);
-		dialogFieldChangedAndApplied();
-	}
-
-	/**
-	 * Sets the text without triggering a dialog-changed event.
-	 */
-	public void setTextWithoutUpdate(String text) {
-		// reset _pending state.
-		_pending = false;
-
-		if (text == null)
-			text = ""; //$NON-NLS-1$
-		_text = text;
-		if (isOkToUse(_textControl)) {
-			_textControl.removeModifyListener(_modifyListener);
-			_textControl.setText(text);
-			_textControl.addModifyListener(_modifyListener);
-		}
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.jsf.common.ui.internal.dialogfield.DialogField#handleGrabHorizontal()
-	 */
-	public void handleGrabHorizontal() {
-		LayoutUtil.setGrabHorizontal(_textControl, true);
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/StyleComboDialogField.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/StyleComboDialogField.java
deleted file mode 100644
index 93c9332..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/StyleComboDialogField.java
+++ /dev/null
@@ -1,398 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import java.util.Map;
-import java.util.TreeMap;
-import java.util.Map.Entry;
-
-import org.eclipse.jst.jsf.common.ui.internal.utils.StyleCombo;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.DisposeEvent;
-import org.eclipse.swt.events.DisposeListener;
-import org.eclipse.swt.events.FocusAdapter;
-import org.eclipse.swt.events.FocusEvent;
-import org.eclipse.swt.events.ModifyEvent;
-import org.eclipse.swt.events.ModifyListener;
-import org.eclipse.swt.events.PaintEvent;
-import org.eclipse.swt.events.PaintListener;
-import org.eclipse.swt.events.SelectionEvent;
-import org.eclipse.swt.events.SelectionListener;
-import org.eclipse.swt.graphics.GC;
-import org.eclipse.swt.graphics.Rectangle;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.ui.forms.FormColors;
-import org.eclipse.ui.forms.widgets.FormToolkit;
-
-/**
- * A dialog field for style combos
- *
- */
-public class StyleComboDialogField extends DialogFieldBase implements
-		ISupportTextValue {
-	final static private int WIDTH_HINT = 10;
-
-	private String _text;
-
-	private int _selectionIndex;
-
-	private String[] _items;
-
-	private StyleCombo _comboControl;
-
-	private ModifyListener _modifyListener;
-
-	private int _flags;
-
-	private boolean _pending = false;
-
-	private Map _entryMap;
-
-	private String _defaultValue;
-
-
-	/**
-	 * @param defaultValue
-	 */
-	public void setDefaultValue(String defaultValue) {
-		this._defaultValue = defaultValue;
-		if (_comboControl != null && ! _comboControl.isDisposed())
-			_comboControl.setDefaultValue(_defaultValue);
-	}
-
-	/**
-	 * @param flags
-	 */
-	public StyleComboDialogField(int flags) {
-		super();
-		_text = ""; //$NON-NLS-1$
-		_items = new String[0];
-		_flags = flags;
-		_selectionIndex = -1;
-	}
-
-	// ------- layout helpers
-
-
-	/*
-	 * @see DialogField#doFillIntoGrid
-	 */
-	public Control[] doFillIntoGrid(FormToolkit toolkit, Composite parent,
-			int nColumns) {
-		assertEnoughColumns(nColumns);
-
-		Control requiredLabel = getRequiredLabelControl(toolkit, parent);
-		requiredLabel.setLayoutData(gridDataForLabel(1));
-
-		Control label = getLabelControl(toolkit, parent);
-		label.setLayoutData(gridDataForLabel(1));
-
-		StyleCombo combo = getComboControl(toolkit, parent);
-		combo.setLayoutData(gridDataForCombo(nColumns - 2));
-
-		return new Control[] { requiredLabel, label, combo };
-	}
-
-	/*
-	 * @see DialogField#getNumberOfControls
-	 */
-	public int getNumberOfControls() {
-		return 3;
-	}
-
-	/**
-	 * @param span
-	 * @return the grid data for the combo
-	 */
-	protected static GridData gridDataForCombo(int span) {
-		GridData gd = new GridData();
-		gd.horizontalAlignment = GridData.FILL;
-		gd.grabExcessHorizontalSpace = false;
-		gd.horizontalSpan = span;
-		gd.widthHint = WIDTH_HINT;
-		return gd;
-	}
-
-	// ------- focus methods
-
-	/*
-	 * @see DialogField#setFocus
-	 */
-	public boolean setFocus() {
-		if (isOkToUse(_comboControl)) {
-			_comboControl.setFocus();
-		}
-		return true;
-	}
-
-	// ------- ui creation
-
-	/**
-	 * Creates or returns the created combo control.
-	 * @param toolkit 
-	 * 
-	 * @param parent
-	 *            The parent composite or <code>null</code> when the widget
-	 *            has already been created.
-	 * @return the combo control
-	 */
-	public StyleCombo getComboControl(FormToolkit toolkit,
-			final Composite parent) {
-		if (_comboControl == null || _comboControl.isDisposed()) {
-			assertCompositeNotNull(parent);
-			_modifyListener = new ModifyListener() {
-				public void modifyText(ModifyEvent e) {
-					doModifyText(e);
-				}
-			};
-			SelectionListener selectionListener = new SelectionListener() {
-				public void widgetSelected(SelectionEvent e) {
-					doSelectionChanged(e);
-				}
-
-				public void widgetDefaultSelected(SelectionEvent e) {
-					handleDefaultSelection(e);
-				}
-			};
-
-			if (toolkit != null) {
-				_comboControl = new StyleCombo(parent, _flags);
-                final FormColors colors = new FormColors(parent.getDisplay());
-				parent.addPaintListener(new PaintListener() {
-
-					public void paintControl(PaintEvent event) {
-						Composite composite = (Composite) event.widget;
-						Control[] children = composite.getChildren();
-						for (int i = 0; i < children.length; i++) {
-							Control c = children[i];
-							if (!(c instanceof StyleCombo) || !c.isVisible()) {
-								continue;
-							}
-							Rectangle b = c.getBounds();
-							GC gc = event.gc;
-							gc.setForeground(colors.getBorderColor());
-							gc.drawRectangle(b.x - 1, b.y - 1, b.width + 1,
-									b.height + 1);
-						}
-					}
-				});
-                
-                // when the parent is disposed, the colors should no
-                // no longer be needed.
-                parent.addDisposeListener(new DisposeListener()
-                {
-                    public void widgetDisposed(DisposeEvent e) {
-                        colors.dispose();
-                    }
-                }
-                );
-				toolkit.adapt(_comboControl);
-			} else {
-				_comboControl = new StyleCombo(parent, _flags | SWT.BORDER);
-				_comboControl.setBackground(Display.getCurrent()
-						.getSystemColor(SWT.COLOR_LIST_BACKGROUND));
-			}
-
-			// moved up due to 1GEUNW2
-			_comboControl.setItems(_items);
-			_comboControl.setDefaultValue(_defaultValue);
-			if (_selectionIndex != -1) {
-				_comboControl.select(_selectionIndex);
-			} else {
-				_comboControl.setText(_text);
-			}
-			_comboControl.setFont(parent.getFont());
-			_comboControl.addModifyListener(_modifyListener);
-			_comboControl.addSelectionListener(selectionListener);
-			_comboControl.addFocusListener(new FocusAdapter() {
-				public void focusLost(FocusEvent e) {
-					doFocusLost(e);
-				}
-			});
-			_comboControl.setEnabled(isEnabled());
-			_comboControl.setToolTipText(getToolTip());
-		}
-		return _comboControl;
-	}
-
-	/**
-	 * @param e
-	 */
-	protected void handleDefaultSelection(SelectionEvent e) {
-		// commit value
-		if (_pending) {
-			_pending = false;
-			dialogFieldApplied();
-		}
-	}
-
-	/**
-	 * @param e
-	 */
-	protected void doFocusLost(FocusEvent e) {
-		if (_pending) {
-			_pending = false;
-			dialogFieldApplied();
-		}
-	}
-
-	private void doModifyText(ModifyEvent e) {
-		if (isOkToUse(_comboControl)) {
-			_text = getEntryKey(_comboControl.getText());
-			_selectionIndex = _comboControl.getSelectionIndex();
-		}
-		_pending = true;
-		dialogFieldChanged();
-	}
-
-	private void doSelectionChanged(SelectionEvent e) {
-		if (isOkToUse(_comboControl)) {
-			_items = _comboControl.getItems();
-			_text = getEntryKey(_comboControl.getText());
-			_selectionIndex = _comboControl.getSelectionIndex();
-		}
-		_pending = false;
-		dialogFieldChangedAndApplied();
-	}
-
-	// ------ enable / disable management
-
-	/*
-	 * @see DialogField#updateEnableState
-	 */
-	protected void updateEnableState() {
-		super.updateEnableState();
-		if (isOkToUse(_comboControl)) {
-			_comboControl.setEnabled(isEnabled());
-		}
-	}
-
-	// ------ text access
-
-	/**
-	 * Sets the combo items. Triggers a dialog-changed event.
-	 * @param items 
-	 */
-	public void setItems(String[] items) {
-		_items = items;
-		if (isOkToUse(_comboControl)) {
-			_comboControl.setItems(items);
-		}
-		_pending = false;
-		// dialogFieldChangedAndApplied();
-	}
-
-	/**
-	 * @param map
-	 */
-	public void setEntryMap(Map map) {
-		this._entryMap = map;
-		if (_entryMap == null) {
-			_entryMap = new TreeMap();
-		}
-		Entry[] entries = (Entry[]) _entryMap.entrySet().toArray(new Entry[0]);
-		String[] items = new String[entries.length];
-		for (int i = 0; i < entries.length; i++) {
-			items[i] = entries[i].getValue().toString();
-		}
-		setItems(items);
-	}
-
-	/**
-	 * Gets the text.
-	 */
-	public String getText() {
-		return _text;
-	}
-
-	/**
-	 * Sets the text. Triggers a dialog-changed event.
-	 */
-	public void setText(String text) {
-		setTextWithoutUpdate(text);
-		_pending = false;
-		dialogFieldChangedAndApplied();
-	}
-
-	/**
-	 * Selects an item.
-	 * @param index 
-	 */
-	public void selectItem(int index) {
-		if (isOkToUse(_comboControl)) {
-			_comboControl.select(index);
-		} else {
-			if (index >= 0 && index < _items.length) {
-				_text = getEntryKey(_items[index]);
-				_selectionIndex = index;
-			}
-		}
-		dialogFieldChangedAndApplied();
-	}
-
-	/**
-	 * @return the selection index
-	 */
-	public int getSelectionIndex() {
-		return _selectionIndex;
-	}
-
-	/**
-	 * Sets the text without triggering a dialog-changed event.
-	 */
-	public void setTextWithoutUpdate(String text) {
-		_pending = false;
-		if (text == null) {
-			text = "";//$NON-NLS-1$
-		}
-		_text = text;
-		if (isOkToUse(_comboControl)) {
-			_comboControl.removeModifyListener(_modifyListener);
-			_comboControl.setText(getEntryValue(text));
-			_comboControl.addModifyListener(_modifyListener);
-		}
-	}
-
-	private String getEntryValue(String key) {
-		if (_entryMap == null || !_entryMap.containsKey(key)) {
-			return key;
-		}
-		return _entryMap.get(key).toString();
-	}
-
-	private String getEntryKey(String value) {
-		if (_entryMap == null || !_entryMap.containsValue(value)) {
-			return value;
-		}
-
-		Entry[] entries = (Entry[]) _entryMap.entrySet().toArray(new Entry[0]);
-		for (int i = 0; i < entries.length; i++) {
-			if (entries[i].getValue() == value
-					|| (value != null && value.equals(entries[i].getValue()))) {
-				return entries[i].getKey().toString();
-			}
-		}
-		return value;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.jsf.common.ui.internal.dialogfield.DialogField#handleGrabHorizontal()
-	 */
-	public void handleGrabHorizontal() {
-		LayoutUtil.setGrabHorizontal(_comboControl, true);
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/TypedElementSelectionValidator.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/TypedElementSelectionValidator.java
deleted file mode 100644
index 8d0e091..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/TypedElementSelectionValidator.java
+++ /dev/null
@@ -1,110 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-import java.util.Collection;
-
-import org.eclipse.core.runtime.Assert;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.ui.dialogs.ISelectionStatusValidator;
-
-/**
- * Implementation of a <code>ISelectionValidator</code> to validate the type
- * of an element. Empty selections are not accepted.
- * 
- * @author mengbo
- * @version 1.5
- */
-/*package*/ class TypedElementSelectionValidator implements
-		ISelectionStatusValidator {
-
-	private IStatus _fgErrorStatus = new StatusInfo(IStatus.ERROR, ""); //$NON-NLS-1$
-
-	private IStatus _fgOKStatus = new StatusInfo();
-
-	private Class[] _fAcceptedTypes;
-
-	private boolean _fAllowMultipleSelection;
-
-	private Collection _fRejectedElements;
-
-	/**
-	 * @param acceptedTypes
-	 *            The types accepted by the validator
-	 * @param allowMultipleSelection
-	 *            If set to <code>true</code>, the validator allows multiple
-	 *            selection.
-	 */
-	public TypedElementSelectionValidator(Class[] acceptedTypes,
-			boolean allowMultipleSelection) {
-		this(acceptedTypes, allowMultipleSelection, null);
-	}
-
-	/**
-	 * @param acceptedTypes
-	 *            The types accepted by the validator
-	 * @param allowMultipleSelection
-	 *            If set to <code>true</code>, the validator allows multiple
-	 *            selection.
-	 * @param rejectedElements
-	 *            A list of elements that are not accepted
-	 */
-	public TypedElementSelectionValidator(Class[] acceptedTypes,
-			boolean allowMultipleSelection, Collection rejectedElements) {
-		Assert.isNotNull(acceptedTypes);
-		_fAcceptedTypes = acceptedTypes;
-		_fAllowMultipleSelection = allowMultipleSelection;
-		_fRejectedElements = rejectedElements;
-	}
-
-	/*
-	 * @see org.eclipse.ui.dialogs.ISelectionValidator#isValid(java.lang.Object)
-	 */
-	public IStatus validate(Object[] elements) {
-		if (isValid(elements)) {
-			return _fgOKStatus;
-		}
-		return _fgErrorStatus;
-	}
-
-	private boolean isOfAcceptedType(Object o) {
-		for (int i = 0; i < _fAcceptedTypes.length; i++) {
-			if (_fAcceptedTypes[i].isInstance(o)) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	private boolean isRejectedElement(Object elem) {
-		return (_fRejectedElements != null)
-				&& _fRejectedElements.contains(elem);
-	}
-
-	private boolean isValid(Object[] selection) {
-		if (selection.length == 0) {
-			return false;
-		}
-
-		if (!_fAllowMultipleSelection && selection.length != 1) {
-			return false;
-		}
-
-		for (int i = 0; i < selection.length; i++) {
-			Object o = selection[i];
-			if (!isOfAcceptedType(o) || isRejectedElement(o)) {
-				return false;
-			}
-		}
-		return true;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/TypedViewerFilter.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/TypedViewerFilter.java
deleted file mode 100644
index 52ecb6a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogfield/TypedViewerFilter.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogfield;
-
-
-import org.eclipse.core.runtime.Assert;
-import org.eclipse.jface.viewers.Viewer;
-import org.eclipse.jface.viewers.ViewerFilter;
-
-/**
- * Viewer filter used in selection dialogs.
- * 
- * @author mengbo
- * @version 1.5
- */
-/*package*/ class TypedViewerFilter extends ViewerFilter {
-
-	private Class[] _fAcceptedTypes;
-
-	private Object[] _fRejectedElements;
-
-	/**
-	 * Creates a filter that only allows elements of gives types.
-	 * 
-	 * @param acceptedTypes
-	 *            The types of accepted elements
-	 */
-	public TypedViewerFilter(Class[] acceptedTypes) {
-		this(acceptedTypes, null);
-	}
-
-	/**
-	 * Creates a filter that only allows elements of gives types, but not from a
-	 * list of rejected elements.
-	 * 
-	 * @param acceptedTypes
-	 *            Accepted elements must be of this types
-	 * @param rejectedElements
-	 *            Element equals to the rejected elements are filtered out
-	 */
-	public TypedViewerFilter(Class[] acceptedTypes, Object[] rejectedElements) {
-		Assert.isNotNull(acceptedTypes);
-		_fAcceptedTypes = acceptedTypes;
-		_fRejectedElements = rejectedElements;
-	}
-
-	/**
-	 * @see ViewerFilter#select(org.eclipse.jface.viewers.Viewer,
-	 *      java.lang.Object, java.lang.Object)
-	 */
-	public boolean select(Viewer viewer, Object parentElement, Object element) {
-		if (_fRejectedElements != null) {
-			for (int i = 0; i < _fRejectedElements.length; i++) {
-				if (element.equals(_fRejectedElements[i])) {
-					return false;
-				}
-			}
-		}
-		for (int i = 0; i < _fAcceptedTypes.length; i++) {
-			if (_fAcceptedTypes[i].isInstance(element)) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogs/CommonResourceDialog.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogs/CommonResourceDialog.java
deleted file mode 100644
index debc2f9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogs/CommonResourceDialog.java
+++ /dev/null
@@ -1,368 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogs;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-import org.eclipse.core.resources.IContainer;
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IFolder;
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.jface.viewers.ITreeContentProvider;
-import org.eclipse.jface.viewers.Viewer;
-import org.eclipse.jface.viewers.ViewerFilter;
-import org.eclipse.jst.jsf.common.ui.JSFUICommonPlugin;
-import org.eclipse.jst.jsf.common.ui.internal.logging.Logger;
-import org.eclipse.jst.jsf.common.ui.internal.utils.WebrootUtil;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.widgets.Shell;
-import org.eclipse.ui.model.WorkbenchLabelProvider;
-import org.eclipse.ui.views.navigator.ResourceComparator;
-
-/**
- * This dialog shows IFile type resources within a IProject domain for
- * selection. The client can prvide the suffixs of files to filter when
- * candidates are shown on the tree.
- * 
- * The usage: Shell shell = new Shell(); IProject project = getProject();
- * CommonResourceDialog dlg = new CommonResourceDialog(shell, project);
- * dlg.setResourceDescription("image"); dlg.setSuffixs(new
- * String[]{"bmp","jpg","gif"}); if(dlg.open() == Window.OK) { IFile
- * selectedFile = (IFile)dlg.getResult()[0]; }
- * 
- * Note: In code above, what you get is an absolute resource path. You can use
- * <code>org.eclipse.wst.sse.core.util.PathHelper.convertToRelative(String input, String base)</code>
- * to convert a absolute resource path to a relative path based on one path.
- * 
- * @author mengbo
- */
-public class CommonResourceDialog extends TreeViewerSelectionDialog {
-	private static Logger _log = JSFUICommonPlugin
-			.getLogger(CommonResourceDialog.class);
-
-	// private static final String STATUS_MESSAGE_0 = CommonPlugin
-	// .getResourceString("Dialog.CommonResourceDialog.StatusMessage0");
-	// //$NON-NLS-1$
-
-	private IProject _project = null;
-
-	private String _suffixs[] = null;
-
-	private CommonResourceFilter _filter = null;
-
-	// The resource type resourceDescription, such as "image", "jsp", "java
-	// class" etc.
-	private String _resourceDescription = null;
-
-	private IFolder _folder;
-
-	// The content provider
-	class ProjectFileDialogContentProvider implements ITreeContentProvider {
-		/**
-		 * The visual part that is using this content provider is about to be
-		 * disposed. Deallocate all allocated SWT resources.
-		 */
-		public void dispose() {
-            // nothing to dispose
-		}
-
-		/**
-		 * @see ITreeContentProvider#getChildren
-		 */
-		public Object[] getChildren(Object element) {
-			if (element instanceof Object[]) {
-				return (Object[]) element;
-			} else if (element instanceof IContainer) {
-				IContainer container = (IContainer) element;
-				if (container.isAccessible()) {
-					try {
-						return container.members();
-					} catch (CoreException e) {
-						_log.error(
-								"Error.ProjectFileDialogContentProvider.0", e); //$NON-NLS-1$
-					}
-				}
-
-			}
-			return new Object[0];
-		}
-
-		/**
-		 * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(Object)
-		 */
-		public Object[] getElements(Object element) {
-			return getChildren(element);
-		}
-
-		/**
-		 * @see ITreeContentProvider#getParent
-		 */
-		public Object getParent(Object element) {
-			if (element instanceof IResource) {
-				return ((IResource) element).getParent();
-			}
-			return null;
-		}
-
-		/**
-		 * @see ITreeContentProvider#hasChildren
-		 */
-		public boolean hasChildren(Object element) {
-			return getChildren(element).length > 0;
-		}
-
-		/**
-		 * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(Viewer, Object, Object)
-		 */
-		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
-            // no viewer change support required
-		}
-
-	}
-
-	// The default resource filter
-	class CommonResourceFilter extends ViewerFilter {
-		private String _filterSuffixs[] = null;
-
-		/**
-		 * @return Returns the _suffixs.
-		 */
-		public String[] getSuffixs() {
-			return _filterSuffixs;
-		}
-
-		/**
-		 * @param _suffixs
-		 *            The _suffixs to set.
-		 */
-		public void setSuffixs(String[] _suffixs) {
-			this._filterSuffixs = _suffixs;
-		}
-
-		/*
-		 * (non-Javadoc)
-		 * 
-		 * @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer,
-		 *      java.lang.Object, java.lang.Object)
-		 */
-		public boolean select(Viewer viewer, Object parentElement,
-				Object element) {
-			if (element instanceof IFile) {
-				IFile file = (IFile) element;
-				if (!WebrootUtil.isUnderWebContentFolder(file)) {
-					return false;
-				}
-				if (isSuffixBlank()) {
-					return true;
-				}
-				if (file.getFileExtension() != null) {
-					if (Arrays.asList(_filterSuffixs).contains(
-							file.getFileExtension().toLowerCase())) {
-						return true;
-					}
-				}
-			} else if (element instanceof IContainer) {
-				if (!((IContainer) element).isAccessible()) {
-					return false;
-				}
-				if (element instanceof IProject) {
-					return true;
-				} else if (element instanceof IFolder) {
-					IContainer container = (IContainer) element;
-					try {
-						IResource[] members = container.members();
-						for (int i = 0; i < members.length; i++) {
-							if (select(viewer, members[i].getParent(),
-									members[i])) {
-								return true;
-							}
-						}
-					} catch (CoreException e) {
-						_log.error(
-								"Error.ProjectFileDialogContentProvider.0", e); //$NON-NLS-1$
-						return false;
-					}
-				}
-			}
-			return false;
-		}
-
-	}
-
-	/**
-	 * This is a dialog for common resource selection, the resouce supported
-	 * include IFolder, IProject, IFile, user can provide
-	 * 
-	 * @param parentShell
-	 * @param project
-	 * @param style 
-	 */
-	public CommonResourceDialog(Shell parentShell, IProject project, int style) {
-		super(parentShell, "", style); //$NON-NLS-1$
-		if (project == null) {
-			throw new IllegalArgumentException(
-					"Argument(project) cannot be null"); //$NON-NLS-1$
-		}
-		_project = project;
-		setContentProvider(new ProjectFileDialogContentProvider());
-		setLabelProvider(WorkbenchLabelProvider
-				.getDecoratingWorkbenchLabelProvider());
-		_filter = new CommonResourceFilter();
-		setFilter(_filter);
-		setViewerComparator(new ResourceComparator(ResourceComparator.TYPE));
-		_project = project;
-		setStatusMessage(getStatusMessage());
-	}
-
-	/**
-	 * Same as CommonResourceDialog(parentShell, project, SWT.NONE)
-	 * 
-	 * @param parentShell
-	 * @param project
-	 */
-	public CommonResourceDialog(Shell parentShell, IProject project) {
-		this(parentShell, project, SWT.NONE);
-	}
-
-	private String getStatusMessage() {
-		if (_resourceDescription == null) {
-			return ""; //$NON-NLS-1$
-		}
-		return _resourceDescription;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.pagedesigner.ui.common.SelectionTreeViewerDialog#findInputElement()
-	 */
-	protected Object findInputElement() {
-		if (_folder != null) {
-			return new Object[] { _folder, };
-		}
-		return new Object[] { _project, };
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.pagedesigner.ui.common.SelectionTreeViewerDialog#isValidSelection(java.lang.Object)
-	 */
-	protected boolean isValidSelection(Object selection) {
-		if (selection instanceof Object[]) {
-			for (int i = 0, n = ((Object[]) selection).length; i < n; i++) {
-				if (isValidElement(((Object[]) selection)[i]) == true) {
-					return true;
-				}
-			}
-			return false;
-		}
-        return isValidElement(selection);
-	}
-
-	private boolean isValidElement(Object selection) {
-		if ((selection instanceof IFile)) {
-			// Null means no filter is set
-			if (isSuffixBlank()) {
-				return true;
-			}
-			// The extension is supported?
-			else if (_suffixs != null
-					&& Arrays.asList(_suffixs).contains(
-							((IFile) selection).getFileExtension()
-									.toLowerCase())) {
-				return true;
-			}
-		}
-		// None of above conditions, invalid.
-		return false;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.ui.dialogs.SelectionDialog#getResult()
-	 */
-	public Object[] getResult() {
-		Object[] objects = super.getResult();
-		if (objects == null || objects.length == 0) {
-			return null;
-		}
-		List list = new ArrayList();
-		for (int i = 0; i < objects.length; i++) {
-			if (objects[i] instanceof IFile) {
-				list.add(objects[i]);
-			}
-		}
-		return list.toArray();
-	}
-
-	/**
-	 * @param suffixs
-	 *            The suffixs to set.
-	 */
-	public void setSuffixs(String[] suffixs) {
-		this._suffixs = convertTolowercase(suffixs);
-		_filter.setSuffixs(_suffixs);
-		setStatusMessage(getStatusMessage());
-	}
-
-	private String[] convertTolowercase(String[] suffixs) {
-		if (suffixs != null) {
-			String[] newSuffixs = new String[suffixs.length];
-			for (int i = 0; i < suffixs.length; i++) {
-				newSuffixs[i] = suffixs[i].toLowerCase();
-			}
-			return newSuffixs;
-		}
-		return null;
-	}
-
-	/**
-	 * @return Returns the sourceDescription.
-	 */
-	public String getResourceDescription() {
-		return _resourceDescription;
-	}
-
-	/**
-	 * @param sourceDescription
-	 *            The sourceDescription to set.
-	 */
-	public void setResourceDescription(String sourceDescription) {
-		this._resourceDescription = sourceDescription;
-		setStatusMessage(getStatusMessage());
-	}
-
-	private boolean isSuffixBlank() {
-		boolean isSuffixBlank = false;
-		if (_suffixs == null) {
-			isSuffixBlank = true;
-		} else {
-			int count = 0;
-			for (int i = 0, size = _suffixs.length; i < size; i++) {
-				if (_suffixs[i] != null && !"".equals(_suffixs[i])) { //$NON-NLS-1$
-					count++;
-					break;
-				}
-			}
-			if (count == 0) {
-				isSuffixBlank = true;
-			}
-		}
-		return isSuffixBlank;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogs/CommonWizardDialog.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogs/CommonWizardDialog.java
deleted file mode 100644
index 3fd719c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogs/CommonWizardDialog.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogs;
-
-import org.eclipse.jface.dialogs.IDialogConstants;
-import org.eclipse.jface.wizard.IWizard;
-import org.eclipse.jface.wizard.WizardDialog;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Shell;
-
-/**
- * Wizard Dialog with a Finish set to OK if no previous
- * or next buttons are needed
- *
- */
-public class CommonWizardDialog extends WizardDialog {
-
-	/**
-	 * @param parentShell
-	 * @param newWizard
-	 */
-	public CommonWizardDialog(Shell parentShell, IWizard newWizard) {
-		super(parentShell, newWizard);
-	}
-
-	protected void createButtonsForButtonBar(Composite parent) {
-		super.createButtonsForButtonBar(parent);
-
-		IWizard wizard = getWizard();
-		if (!wizard.needsPreviousAndNextButtons()) {
-			getButton(IDialogConstants.FINISH_ID).setText(
-					IDialogConstants.OK_LABEL);
-		}
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogs/ResourceOnClasspathDialog.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogs/ResourceOnClasspathDialog.java
deleted file mode 100644
index 934957d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogs/ResourceOnClasspathDialog.java
+++ /dev/null
@@ -1,254 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogs;
-
-import java.io.File;
-import java.util.Arrays;
-
-import org.eclipse.core.resources.IContainer;
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.resources.IWorkspace;
-import org.eclipse.core.resources.ResourcesPlugin;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.jdt.core.IJarEntryResource;
-import org.eclipse.jdt.core.IJavaElement;
-import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.core.JavaCore;
-import org.eclipse.jdt.ui.JavaElementLabelProvider;
-import org.eclipse.jdt.ui.StandardJavaElementContentProvider;
-import org.eclipse.jface.viewers.Viewer;
-import org.eclipse.jface.viewers.ViewerFilter;
-import org.eclipse.jst.jsf.common.ui.IFileFolderConstants;
-import org.eclipse.jst.jsf.common.ui.JSFUICommonPlugin;
-import org.eclipse.jst.jsf.common.ui.internal.utils.PathUtil;
-import org.eclipse.swt.widgets.Shell;
-
-/**
- * This dialog will let client to select resources that located on a
- * IJavaProject classpath, the client can provide a list of files suffixs to
- * filter.
- * 
- * @author mengbo
- */
-// TODO: Since many jar files might do nothing to do with client's selection, we
-// may need to provides more filter choice
-// to clients to exclude unnecessary jar files, such as that are located in JDK
-// dir.
-public class ResourceOnClasspathDialog extends TreeViewerSelectionDialog {
-	// ResourcesOnClasspathDialog.statusMessage = Please select a property file
-	private static final String STATUS_MESSAGE = JSFUICommonPlugin
-			.getResourceString("Dialog.ResourceOnClasspathDialog.StatusMessage"); //$NON-NLS-1$
-
-	private IJavaProject _javaProject;
-
-	// the suffixs of files that can be selected
-	private String _suffixs[];
-
-	// IJMTConstants.DEFAULT_SUFFIX;
-
-	private ResourceOnClasspathFilter _filter;
-
-	// Client doesn't need to know it.
-	class ResourceOnClasspathFilter extends ViewerFilter {
-		StandardJavaElementContentProvider _javaContentProvider;
-
-		/**
-		 * @param contentProvider
-		 */
-		public ResourceOnClasspathFilter(
-				StandardJavaElementContentProvider contentProvider) {
-			_javaContentProvider = contentProvider;
-		}
-
-		/**
-		 * Set the suffixs of files need to be selected.
-		 * 
-		 * @param suffixs
-		 */
-		public void setSuffixs(String suffixs[]) {
-			_suffixs = suffixs;
-		}
-
-		/**
-		 * @param contentProvider
-		 *            The _javaContentProvider to set.
-		 */
-		public void setJavaContentProvider(
-				StandardJavaElementContentProvider contentProvider) {
-			_javaContentProvider = contentProvider;
-		}
-
-		/**
-		 * @param project
-		 *            The _javaProject to set.
-		 */
-		public void setJavaProject(IJavaProject project) {
-			_javaProject = project;
-		}
-
-		/*
-		 * (non-Javadoc)
-		 * 
-		 * @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer,
-		 *      java.lang.Object, java.lang.Object)
-		 */
-		public boolean select(Viewer viewer, Object parentElement,
-				Object element) {
-			// TODO: This logic can be improved by add caching mechanism
-			if (element instanceof IJavaProject) {
-				String currentProjectName = ((IJavaProject) element)
-						.getProject().getFullPath().toString().trim();
-				String projectName = _javaProject.getProject().getFullPath()
-						.toString().trim();
-				if (projectName.equalsIgnoreCase(currentProjectName)) {
-					return true;
-				}
-                return false;
-			} else if (element instanceof IResource) {
-				if (((_javaProject != null) && !_javaProject
-						.isOnClasspath((IResource) element))) {
-					return false;
-				}
-				if (element instanceof IFile) {
-					if (Arrays.asList(_suffixs).contains(
-							((IFile) element).getFileExtension())) {
-						return true;
-					}
-				}
-				return false;
-			}
-
-			if (element instanceof IJarEntryResource) {
-				String ext = ((IJarEntryResource) element).getFullPath()
-						.getFileExtension();
-				if (ext != null && Arrays.asList(_suffixs).contains(ext)) {
-					return true;
-				}
-                return false;
-			}
-			if (!(element instanceof IJavaElement)) {
-				return false;
-			}
-			if (((_javaProject != null) && !_javaProject
-					.isOnClasspath((IJavaElement) element))) {
-				return false;
-			}
-			IJavaElement javaElement = (IJavaElement) element;
-			Object[] children = null;
-			switch (javaElement.getElementType()) {
-			case IJavaElement.PACKAGE_FRAGMENT_ROOT:
-				children = _javaContentProvider.getChildren(javaElement);
-				break;
-			case IJavaElement.IMPORT_CONTAINER:
-				return true;
-			case IJavaElement.PACKAGE_FRAGMENT:
-				children = _javaContentProvider.getChildren(javaElement);
-				break;
-			case IJavaElement.CLASS_FILE:
-				if (Arrays.asList(_suffixs).contains(
-						IFileFolderConstants.EXT_CLASS)) {
-					return true;
-				} 
-                return false;
-			case IJavaElement.COMPILATION_UNIT:
-				String ext = javaElement.getPath().getFileExtension();
-				if (ext != null && Arrays.asList(_suffixs).contains(ext)) {
-					return true;
-				} 
-                return false;
-			default:
-				return false;
-			}
-
-			for (int i = 0; i < children.length; i++) {
-				if (select(viewer, javaElement, children[i])) {
-					return true;
-				}
-			}
-			// Either the resouce or its children are not for displaying.
-			return false;
-		}
-	}
-
-	/**
-	 * Set the suffixs of files need to be selected.
-	 * 
-	 * @param suffixs
-	 */
-	public void setSuffixs(String suffixs[]) {
-		_suffixs = suffixs;
-		_filter.setSuffixs(suffixs);
-	}
-
-	/**
-	 * @param parentShell
-	 * @param project
-	 */
-	public ResourceOnClasspathDialog(Shell parentShell, IJavaProject project) {
-		super(parentShell, STATUS_MESSAGE);
-		// set provider and filter
-		StandardJavaElementContentProvider contentProvider = new StandardJavaElementContentProvider();
-		setContentProvider(contentProvider);
-		setLabelProvider(new JavaElementLabelProvider());
-		_filter = new ResourceOnClasspathFilter(contentProvider);
-		setFilter(_filter);
-		// store the project
-		_javaProject = project;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.ui.dialogs.SelectionDialog#getResult()
-	 */
-	public Object[] getResult() {
-		Object[] objects = super.getResult();
-		if (objects == null || objects.length == 0) {
-			return null;
-		}
-		IPath path = PathUtil.getPathOnClasspath(_javaProject, objects[0]);
-		String result = null;
-		if (path.segmentCount() == 0) {
-			return new Object[] { "" }; //$NON-NLS-1$
-		}
-		path = path.removeFileExtension();
-		result = path.toOSString();
-		result = result.replace(File.separatorChar, '.');
-		return new Object[] { result };
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.pagedesigner.ui.common.SelectionTreeViewerDialog#isValidSelection()
-	 */
-	protected boolean isValidSelection(Object selection) {
-		String extension = PathUtil.getPathOnClasspath(_javaProject, selection)
-				.getFileExtension();
-		return (extension != null && Arrays.asList(_suffixs).contains(extension));
-	}
-
-	protected Object findInputElement() {
-		Object input = ResourcesPlugin.getWorkspace();
-		if (input instanceof IWorkspace) {
-			return JavaCore.create(((IWorkspace) input).getRoot());
-		} else if (input instanceof IContainer) {
-			IJavaElement element = JavaCore.create((IContainer) input);
-			if (element != null && element.exists()) {
-				return element;
-			}
-			return input;
-		}
-        return JavaCore.create(ResourcesPlugin.getWorkspace().getRoot());
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogs/TreeViewerSelectionDialog.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogs/TreeViewerSelectionDialog.java
deleted file mode 100644
index 3214dbd..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/dialogs/TreeViewerSelectionDialog.java
+++ /dev/null
@@ -1,393 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.dialogs;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.jface.dialogs.Dialog;
-import org.eclipse.jface.resource.JFaceResources;
-import org.eclipse.jface.viewers.DoubleClickEvent;
-import org.eclipse.jface.viewers.IDoubleClickListener;
-import org.eclipse.jface.viewers.ILabelProvider;
-import org.eclipse.jface.viewers.ISelection;
-import org.eclipse.jface.viewers.ISelectionChangedListener;
-import org.eclipse.jface.viewers.IStructuredSelection;
-import org.eclipse.jface.viewers.ITreeContentProvider;
-import org.eclipse.jface.viewers.SelectionChangedEvent;
-import org.eclipse.jface.viewers.StructuredSelection;
-import org.eclipse.jface.viewers.TreeViewer;
-import org.eclipse.jface.viewers.ViewerComparator;
-import org.eclipse.jface.viewers.ViewerFilter;
-import org.eclipse.jface.viewers.ViewerSorter;
-import org.eclipse.jst.jsf.common.ui.JSFUICommonPlugin;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.graphics.Image;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.layout.GridLayout;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Label;
-import org.eclipse.swt.widgets.Shell;
-import org.eclipse.ui.dialogs.SelectionDialog;
-import org.eclipse.ui.part.DrillDownComposite;
-
-/**
- * This is a base dialog that uses TreeViewer to show selections, subclass needs
- * to provide IContentProvider, ILabelProvider and ViewerFilter for the
- * TreeViewer. Subclass needs to implement isValidSelection(), which valids the
- * selection, and findInputElement() which provides the root element of the
- * tree. Besides, subclass might need to implement getResult() to return a
- * customized result.
- * 
- * @author mengbo
- * 
- */
-public abstract class TreeViewerSelectionDialog extends SelectionDialog {
-	private static final String DEFAULT_TITLE = JSFUICommonPlugin
-			.getResourceString("Dialog.TreeViewerSelectionDialog.DefaultTitle"); //$NON-NLS-1$
-
-	/** Used to tag the image type */
-	public static final int STYLE_NONE = 0;
-
-	private static final int STYLE_INFORMATION = 1;
-
-	private static final int STYLE_ERROR = 2;
-
-	private static final int STYLE_WARNING = 3;
-
-	/** Sizi of the TreeViewer composite */
-	private static final int SIZING_SELECTION_PANE_HEIGHT = 300;
-
-	private static final int SIZING_SELECTION_PANE_WIDTH = 320;
-
-	private String _title = DEFAULT_TITLE;
-
-	// the seleciton on the treeviewer.
-	private static Object[] _selection;
-
-	// providers
-	private ITreeContentProvider _contentProvider;
-
-	private ILabelProvider _labelProvider;
-
-	private ViewerFilter _filter;
-
-	/** The validation image */
-	private Label _statusImage;
-
-	/** The validation message */
-	private Label _statusLabel;
-
-	private String _statusMessage;
-
-	/** The selection tree */
-	private TreeViewer _treeViewer;
-
-	private int _style;
-
-	private ViewerSorter _viewerSorter = null;
-	private ViewerComparator _viewerComparator = null;
-	/**
-	 * @param parentShell
-	 * @param statusMessage 
-	 * @param style 
-	 */
-	public TreeViewerSelectionDialog(Shell parentShell, String statusMessage,
-			int style) {
-		super(parentShell);
-		_statusMessage = statusMessage;
-		_style = style;
-		setShellStyle(SWT.CLOSE | SWT.TITLE | SWT.BORDER
-				| SWT.APPLICATION_MODAL | SWT.RESIZE);
-	}
-
-	/**
-	 * Convenience for TreeViewerSelectionDialog(parentShell, statusMessage, SWT.NONE)
-	 * 
-	 * @param parentShell
-	 * @param statusMessage
-	 */
-	public TreeViewerSelectionDialog(Shell parentShell, String statusMessage) {
-		this(parentShell, statusMessage, SWT.NONE);
-	}
-
-	public void setTitle(String title) {
-		super.setTitle(title);
-		_title = title;
-	}
-
-	/**
-	 * Returns a new drill down viewer for this dialog.
-	 * @param parent 
-	 */
-	protected void createTreeViewer(Composite parent) {
-		// Create drill down
-		DrillDownComposite drillDown = new DrillDownComposite(parent,
-				SWT.BORDER);
-		GridData spec = new GridData(GridData.FILL_BOTH);
-		spec.widthHint = SIZING_SELECTION_PANE_WIDTH;
-		spec.heightHint = SIZING_SELECTION_PANE_HEIGHT;
-		drillDown.setLayoutData(spec);
-		_treeViewer = new TreeViewer(drillDown, _style);
-		drillDown.setChildTree(_treeViewer);
-	}
-
-	private void setTreeViewerProviders() {
-		_treeViewer.setContentProvider(_contentProvider);
-		_treeViewer.setLabelProvider(_labelProvider);
-		if (_viewerSorter == null) {
-			_viewerSorter = new ViewerSorter();
-		}
-		_treeViewer.setSorter(_viewerSorter);
-		
-		// override if not null.. setSorter is discouraged.
-		if (_viewerComparator != null)
-		{
-		    _treeViewer.setComparator(_viewerComparator);
-		}
-		_treeViewer.addSelectionChangedListener(new ISelectionChangedListener() {
-					public void selectionChanged(SelectionChangedEvent event) {
-						_selection = getSelectedElements((IStructuredSelection) event
-								.getSelection());
-						updateStatus();
-					}
-				});
-		_treeViewer.addDoubleClickListener(new IDoubleClickListener() {
-			public void doubleClick(DoubleClickEvent event) {
-				ISelection selection = event.getSelection();
-				if (selection instanceof IStructuredSelection) {
-					Object item = ((IStructuredSelection) selection)
-							.getFirstElement();
-					if (item instanceof IFile) {
-						okPressed();
-					} else if (_treeViewer.getExpandedState(item)) {
-						_treeViewer.collapseToLevel(item, 1);
-					} else {
-						_treeViewer.expandToLevel(item, 1);
-					}
-				}
-			}
-		});
-		_treeViewer.setInput(findInputElement());
-
-		if (_filter != null) {
-			_treeViewer.addFilter(_filter);
-		}
-	}
-
-	/**
-	 * Creates the contents of the composite.
-	 * @param parent 
-	 */
-	protected void createTreeViewerComposite(Composite parent) {
-		Composite treeViewerComposite = new Composite(parent, SWT.NONE);
-		GridLayout layout = new GridLayout();
-		layout.marginWidth = 0;
-		treeViewerComposite.setLayout(layout);
-
-		GridData gridData = new GridData(GridData.FILL_HORIZONTAL);
-		gridData.horizontalSpan = 2;
-		treeViewerComposite.setLayoutData(gridData);
-		Label label = new Label(treeViewerComposite, SWT.WRAP);
-		label.setText(_title);
-		label.setFont(treeViewerComposite.getFont());
-		createTreeViewer(treeViewerComposite);
-		Dialog.applyDialogFont(treeViewerComposite);
-	}
-
-	/**
-	 * Sets the selected existing container.
-	 * @param selection 
-	 */
-	public void setSelectedElement(Object[] selection) {
-		// Expand to and select the specified container
-		if (selection == null) {
-			return;
-		}
-
-		for (int i = 0; i < selection.length; i++) {
-			if (_selection[i] != null) {
-				_treeViewer.expandToLevel(_selection[i], 1);
-
-			}
-		}
-		_treeViewer.setSelection(new StructuredSelection(selection), true);
-	}
-
-	/*
-	 * (non-Javadoc) Method declared on Dialog.
-	 */
-	protected Control createDialogArea(Composite parent) {
-		Composite area = (Composite) super.createDialogArea(parent);
-		GridLayout gridLayout = new GridLayout();
-		gridLayout.numColumns = 2;
-		area.setLayout(gridLayout);
-
-		// Container treeviewer composite
-		createTreeViewerComposite(area);
-
-		_statusImage = createLabel(area);
-		_statusImage.setImage(getMessageImage(STYLE_ERROR));
-		_statusLabel = createLabel(area);
-		// Link to model
-		setTreeViewerProviders();
-
-		return dialogArea;
-	}
-
-	private Label createLabel(Composite parent) {
-		Label label = new Label(parent, SWT.LEFT);
-		GridData data = new GridData();
-		data.horizontalSpan = 1;
-		data.horizontalAlignment = GridData.FILL;
-		label.setLayoutData(data);
-		label.setText(_statusMessage == null ? "" : _statusMessage); //$NON-NLS-1$
-		return label;
-	}
-
-	private Object[] getSelectedElements(IStructuredSelection selection) {
-		return selection.toArray();
-	}
-
-	/**
-	 * @param provider
-	 *            The _contentProvider to set.
-	 */
-	public void setContentProvider(ITreeContentProvider provider) {
-		_contentProvider = provider;
-	}
-
-	/**
-	 * @param provider
-	 *            The _labelProvider to set.
-	 */
-	public void setLabelProvider(ILabelProvider provider) {
-		_labelProvider = provider;
-	}
-
-	/**
-	 * @param filter
-	 *            The _filter to set.
-	 */
-	public void setFilter(ViewerFilter filter) {
-		this._filter = filter;
-	}
-
-	/**
-	 * @param sorter
-	 *            The _viewerSorter to set.
-	 */
-	public void setViewerSorter(ViewerSorter sorter) {
-		_viewerSorter = sorter;
-	}
-
-	/**
-	 * Set the viewer comparator.  If not null, it's set after after the
-	 * viewer sorter and thus overrides it.
-	 * 
-	 * @param viewerComparator
-	 */
-	public void setViewerComparator(ViewerComparator viewerComparator)
-    {
-        _viewerComparator = viewerComparator;
-    }
-
-    /**
-	 * @param message
-	 */
-	public void setStatusMessage(String message) {
-		_statusMessage = message;
-	}
-
-	/**
-	 * Update the status message
-	 */
-	private void updateStatus() {
-		Object selection = _selection;
-		if (_selection != null && _selection.length == 1) {
-			selection = _selection[0];
-		}
-		if (isValidSelection(selection)) {
-			_statusImage.setVisible(false);
-			_statusLabel.setText(""); //$NON-NLS-1$
-			getOkButton().setEnabled(true);
-		} else {
-			_statusImage.setVisible(true);
-			_statusImage.setImage(getMessageImage(STYLE_ERROR));
-			_statusImage.redraw();
-			_statusLabel.setText(_statusMessage);
-			getOkButton().setEnabled(false);
-		}
-
-	}
-
-	/**
-	 * Get the different message according the message type.
-	 * @param imageType 
-	 * 
-	 * @return Image - the message image
-	 */
-	protected Image getMessageImage(int imageType) {
-		switch (imageType) {
-		case STYLE_ERROR:
-			return JFaceResources.getImage(Dialog.DLG_IMG_MESSAGE_ERROR);
-		case STYLE_WARNING:
-			return JFaceResources.getImage(Dialog.DLG_IMG_MESSAGE_WARNING);
-		case STYLE_INFORMATION:
-			return JFaceResources.getImage(Dialog.DLG_IMG_MESSAGE_INFO);
-		default:
-			return null;
-		}
-	}
-
-	/**
-	 * The <code>ContainerSelectionDialog</code> implementation of this
-	 * <code>Dialog</code> method builds a list of the selected resource
-	 * containers for later retrieval by the client and closes this dialog.
-	 */
-	protected void okPressed() {
-		List chosenContainerPathList = new ArrayList();
-		if (_selection != null) {
-			chosenContainerPathList.addAll(Arrays.asList(_selection));
-		}
-		setResult(chosenContainerPathList);
-		super.okPressed();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jface.window.Window#createContents(org.eclipse.swt.widgets.Composite)
-	 */
-	protected Control createContents(Composite parent) {
-		Control control = super.createContents(parent);
-		if (_selection != null) {
-			this.setSelectedElement(_selection);
-		}
-		return control;
-	}
-
-	/**
-	 * @param selection
-	 * @return true if selection is valid
-	 */
-	protected abstract boolean isValidSelection(Object selection);
-
-	/**
-	 * Used to set the input element on the tree viewer
-	 * @return the input element
-	 */
-	protected abstract Object findInputElement();
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/form/AbstractDetailsForm.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/form/AbstractDetailsForm.java
deleted file mode 100644
index 887d57f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/form/AbstractDetailsForm.java
+++ /dev/null
@@ -1,147 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.form;
-
-import org.eclipse.jface.viewers.ISelection;
-import org.eclipse.jface.viewers.IStructuredSelection;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.ui.forms.widgets.FormToolkit;
-
-/**
- * The parent of all detail forms.
- * 
- * @author cbateman
- *
- */
-public abstract class AbstractDetailsForm
-{
-    private FormToolkit _toolkit;
-
-    /**
-     * 
-     */
-    protected AbstractDetailsForm()
-    {
-        super();
-    }
-
-    /**
-     * Called to refresh model if stale
-     */
-    public void refresh()
-    {
-        // do nothing by default
-    }
-
-    /**
-     * Called before createContents.
-     * 
-     * @param toolkit
-     */
-    public final void initialize(final FormToolkit toolkit)
-    {
-        _toolkit = toolkit;
-        doInitialize();
-    }
-    
-    /**
-     * Override to customize initialization.  getToolkit() is safe to call
-     * from this method.  You should not make other state assumptions.
-     */
-    protected void doInitialize()
-    {
-        // do nothing by default; 
-    }
-    
-    /**
-     * Callled by MasterDetailBlock during it's dispose
-     */
-    public abstract void dispose();
-
-    /**
-     * @param onSave
-     */
-    public abstract void commit(boolean onSave);
-
-    /**
-     * Called on this details form before it is shown, when it becomes active
-     * due to a matching selection change in the master form.  Implementer
-     * should use newSelection as the new instance of their model and 
-     * reinitialize UI as appropriate.
-     * @param newSelection
-     */
-    protected abstract void doUpdateSelection(final Object newSelection);
-
-    /**
-     * @return the contents control.  Must not be called before createContents.
-     */
-    public abstract Control getControl();
-
-    /**
-     * Fired to indicate that this detail form is now selected based on the
-     * master form selected.
-     * 
-     * @param selection
-     */
-    public void selectionChanged(final ISelection selection)
-    {
-        // by default, get the first element of the selection if there is
-        // one and call doUpdateSelection on it.  Sub-classes may change
-        // this behaviour
-        if (selection instanceof IStructuredSelection)
-        {
-            final Object selectionObj = ((IStructuredSelection) selection)
-                    .getFirstElement();
-            doUpdateSelection(selectionObj);
-        }
-    }
-
-    /**
-     * Create the contents of the detail form using 'parent'.  Should not be
-     * called before initialize.
-     * 
-     * @param parent
-     */
-    public abstract void createContents(Composite parent);
-
-    /**
-     * @return the form toolkit in use.  Should not be called before 
-     * initialize.
-     */
-    protected final FormToolkit getToolkit()
-    {
-        return _toolkit;
-    }
-
-    /**
-     * @return true if the form is dirty
-     */
-    public boolean isDirty()
-    {
-        // never dirty by default
-        return false;
-    }
-
-    /**
-     * @return true if form is stale
-     */
-    public boolean isStale()
-    {
-        // always stale by default
-        return true;
-    }
-
-    /**
-     * Called to set focus on the detail form's control
-     */
-    public abstract void setFocus();
-}
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/form/AbstractMasterDetailBlock.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/form/AbstractMasterDetailBlock.java
deleted file mode 100644
index 7141dcb..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/form/AbstractMasterDetailBlock.java
+++ /dev/null
@@ -1,206 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.form;
-
-import java.util.List;
-
-import org.eclipse.jface.viewers.ISelectionChangedListener;
-import org.eclipse.jface.viewers.IStructuredSelection;
-import org.eclipse.jface.viewers.SelectionChangedEvent;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.custom.BusyIndicator;
-import org.eclipse.swt.custom.SashForm;
-import org.eclipse.swt.custom.StackLayout;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.layout.GridLayout;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.ui.forms.widgets.Form;
-import org.eclipse.ui.forms.widgets.FormToolkit;
-
-/**
- * An alternative to MasterDetailBlock that doesn't use the ScrolledForm
- * that causes problems as described here:
- * 
- * http://dev.eclipse.org/newslists/news.eclipse.platform/msg73145.html
-
- * @author cbateman
- *
- */
-public abstract class AbstractMasterDetailBlock implements
-        ISelectionChangedListener
-{
-    private AbstractMasterForm        _masterForm;
-    private Composite                 _detailsPanel;
-    private AbstractDetailsForm       _curPage;
-    private FormToolkit               _toolkit;
-    private StackLayout               _detailLayout;
-    private List<AbstractDetailsForm> _detailForms;
-    private BlankDetailsForm          _blankDetails;
-
-    /**
-     * 
-     */
-    protected AbstractMasterDetailBlock()
-    {
-        super();
-    }
-
-    /**
-     * Disposes the master detail form
-     */
-    public final void dispose()
-    {
-        _masterForm.dispose();
-
-        for (final AbstractDetailsForm detailsForm : _detailForms)
-        {
-            detailsForm.dispose();
-        }
-
-        doDispose();
-    }
-
-    /**
-     * Override to get custom dispose logic. Do not use this to dispose of
-     * master or details forms. This is done automatically for you before
-     * doDispose is called.
-     */
-    protected void doDispose()
-    {
-        // do nothing by default
-    }
-
-    /**
-     * @param toolkit
-     * @param form
-     */
-    public final void createContent(final FormToolkit toolkit, final Form form)
-    {
-        _toolkit = toolkit;
-
-        final GridLayout layout = new GridLayout();
-        layout.marginWidth = 5;
-        layout.marginHeight = 5;
-        form.getBody().setLayout(layout);
-        final SashForm sashForm = new SashForm(form.getBody(), SWT.NULL);
-        // sashForm.setData("form", managedForm); //$NON-NLS-1$
-        _toolkit.adapt(sashForm, false, false);
-        sashForm.setMenu(form.getBody().getMenu());
-        sashForm.setLayoutData(new GridData(GridData.FILL_BOTH));
-        initializeMasterPart(_toolkit, sashForm);
-        createDetailsPart(sashForm);
-
-        _masterForm.createHead(form);
-        createToolBarActions(form);
-        form.updateToolBar();
-    }
-
-    /**
-     * @param toolkit
-     * @return the master form.
-     */
-    protected abstract AbstractMasterForm createMasterPart(
-            final FormToolkit toolkit);
-
-    private void initializeMasterPart(final FormToolkit toolkit,
-            final Composite parent)
-    {
-        _masterForm = createMasterPart(toolkit);
-        _masterForm.initialize(this);
-        _masterForm.createClientArea(parent);
-    }
-
-    private void createToolBarActions(final Form form)
-    {
-        _masterForm.contributeActions(form.getToolBarManager());
-    }
-
-    private void createDetailsPart(final Composite parent)
-    {
-        _detailsPanel = new Composite(parent, SWT.NONE);
-        _detailLayout = new StackLayout();
-        _detailsPanel.setLayout(_detailLayout);
-
-        _detailForms = createDetailPages();
-
-        for (final AbstractDetailsForm detailForm : _detailForms)
-        {
-            detailForm.initialize(_toolkit);
-            detailForm.createContents(_detailsPanel);
-        }
-
-        // create default blank page
-        _blankDetails = new BlankDetailsForm();
-        _blankDetails.initialize(_toolkit);
-        _blankDetails.createContents(_detailsPanel);
-
-        _curPage = _blankDetails;
-        _detailLayout.topControl = _curPage.getControl();
-        _detailsPanel.layout();
-    }
-
-    public final void selectionChanged(final SelectionChangedEvent event)
-    {
-        final Object selectedObj = ((IStructuredSelection) event.getSelection())
-                .getFirstElement();
-        final AbstractDetailsForm page = selectPage(selectedObj);
-        if (page != null)
-        {
-            final AbstractDetailsForm fpage = page;
-            BusyIndicator.showWhile(_detailsPanel.getDisplay(), new Runnable()
-            {
-                public void run()
-                {
-                    final AbstractDetailsForm oldPage = _curPage;
-                    _curPage = fpage;
-                    // commit the current page
-                    if (oldPage != null && oldPage.isDirty())
-                    {
-                        oldPage.commit(false);
-                    }
-                    // refresh the new page
-                    if (fpage.isStale())
-                    {
-                        fpage.refresh();
-                    }
-                    _curPage.selectionChanged(event.getSelection());
-                    // _pageBook.showPage(_curPage.getTextSection().getControl());
-                    _detailLayout.topControl = _curPage.getControl();
-                    _detailsPanel.layout();
-                }
-            });
-        }
-    }
-
-    /**
-     * @return a list of detail forms
-     */
-    protected abstract List<AbstractDetailsForm> createDetailPages();
-
-    /**
-     * @param forModel
-     * @return the details form for 'forModel'. If implementer returns null,
-     *         then a blank page will be provided
-     */
-    protected abstract AbstractDetailsForm doSelectPage(final Object forModel);
-
-    private AbstractDetailsForm selectPage(final Object forModel)
-    {
-        final AbstractDetailsForm clientForm = doSelectPage(forModel);
-
-        if (clientForm != null)
-        {
-            return clientForm;
-        }
-        return _blankDetails;
-    }
-
-}
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/form/AbstractMasterForm.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/form/AbstractMasterForm.java
deleted file mode 100644
index 46ec864..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/form/AbstractMasterForm.java
+++ /dev/null
@@ -1,165 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.form;
-
-import org.eclipse.jface.action.IToolBarManager;
-import org.eclipse.jface.action.ToolBarManager;
-import org.eclipse.jface.viewers.ISelectionChangedListener;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.DisposeEvent;
-import org.eclipse.swt.events.DisposeListener;
-import org.eclipse.swt.layout.RowLayout;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.ToolBar;
-import org.eclipse.ui.forms.widgets.Form;
-import org.eclipse.ui.forms.widgets.FormToolkit;
-
-/**
- * 
- * @author cbateman
- * 
- */
-public abstract class AbstractMasterForm
-{
-
-    private final FormToolkit         _toolkit;
-    private ISelectionChangedListener _listener;
-    private ToolBarManager            _toolBarManager;
-
-    /**
-     * @param toolkit
-     */
-    protected AbstractMasterForm(FormToolkit toolkit)
-    {
-        super();
-        _toolkit = toolkit;
-    }
-
-    /**
-     * @param listener
-     *            the selection listener that is signalled to indicate the
-     *            selection in the master has changed and the detail should be
-     *            updated.
-     */
-    public final void initialize(final ISelectionChangedListener listener)
-    {
-        _listener = listener;
-        doInitialize();
-    }
-
-    /**
-     * It is safe to call getListener() and get getToolkit() in this method. All
-     * other methods should be considered unavailable.
-     */
-    protected void doInitialize()
-    {
-        // do nothing by default; override to do customize init
-    }
-
-    /**
-     * @param parent
-     * @return the client area for the master form, using parent is the parent
-     * control.
-     */
-    public abstract Control createClientArea(final Composite parent);
-
-    /**
-     * @param form
-     */
-    public final void createHead(final Form form)
-    {
-        final Composite head = form.getHead();
-        final Composite container = getToolkit().createComposite(head);
-        container.setLayout(new RowLayout());
-
-        // sub-class contribution
-        contributeToHeadArea(getToolkit(), container);
-
-        _toolBarManager = new ToolBarManager(SWT.FLAT);
-        ToolBar toolbar = _toolBarManager.createControl(container);
-        // _toolkit.adapt(toolbar, false, false);
-
-        toolbar.setBackground(form.getHead().getBackground());
-        toolbar.setForeground(form.getHead().getForeground());
-        //toolbar.setCursor(FormsResources.getHandCursor());
-        container.addDisposeListener(new DisposeListener()
-        {
-            public void widgetDisposed(DisposeEvent e)
-            {
-                if (_toolBarManager != null)
-                {
-                    _toolBarManager.dispose();
-                    _toolBarManager = null;
-                }
-            }
-        });
-
-        form.setHeadClient(container);
-
-    }
-
-    /**
-     * Override to add client area before the toolbar.
-     * 
-     * @param toolkit
-     * @param container
-     */
-    protected void contributeToHeadArea(FormToolkit toolkit, Composite container)
-    {
-        // do nothing by default
-    }
-
-    /**
-     * @param formManager
-     */
-    public final void contributeActions(final IToolBarManager formManager)
-    {
-        contributeActions(formManager, _toolBarManager);
-    }
-
-    /**
-     * @param formManager
-     *            adds to the toolkit's toolbar
-     * @param localManager
-     *            adds to AbstractMasterForm's toolbar.
-     */
-    protected void contributeActions(final IToolBarManager formManager,
-            final IToolBarManager localManager)
-    {
-        // do nothing by default. Override to add actions.
-    }
-
-    /**
-     * Should be called at any time after initialize and createContents when the
-     * owner is finished with the master-detail form block.
-     */
-    public void dispose()
-    {
-        // do nothing by default;
-    }
-
-    /**
-     * @return the tool kit in use.
-     */
-    protected final FormToolkit getToolkit()
-    {
-        return _toolkit;
-    }
-
-    /**
-     * @return the selection listener
-     */
-    protected final ISelectionChangedListener getListener()
-    {
-        return _listener;
-    }
-}
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/form/AbstractXMLSectionsDetailsForm.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/form/AbstractXMLSectionsDetailsForm.java
deleted file mode 100644
index 902ec7e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/form/AbstractXMLSectionsDetailsForm.java
+++ /dev/null
@@ -1,186 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.form;
-
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
-
-import org.eclipse.jface.viewers.ISelection;
-import org.eclipse.jface.viewers.IStructuredSelection;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.layout.RowData;
-import org.eclipse.swt.layout.RowLayout;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.ui.forms.widgets.ExpandableComposite;
-import org.eclipse.ui.forms.widgets.FormText;
-import org.eclipse.ui.forms.widgets.FormToolkit;
-import org.eclipse.ui.forms.widgets.Section;
-
-/**
- * A detail form that uses XML text sections.
- * 
- * @author cbateman
- * 
- */
-public abstract class AbstractXMLSectionsDetailsForm extends
-        AbstractDetailsForm
-{
-    private Map<Object, XMLTextSection> _textSections;
-    private Composite                   _detailFormComposite;
-
-    /**
-     * @param parent
-     */
-    @Override
-    public final void createContents(final Composite parent)
-    {
-        _detailFormComposite = getToolkit().createComposite(parent, SWT.NONE);
-        final RowLayout rowLayout = new RowLayout(SWT.VERTICAL);
-        rowLayout.fill = true;
-        _detailFormComposite.setLayout(rowLayout);
-        // take a copy of what's returned so the sub-class can't control
-        // the map reference
-        _textSections = Collections
-                .unmodifiableMap(new HashMap<Object, XMLTextSection>(
-                        createXMLTextSections(_detailFormComposite)));
-
-        final Set<XMLTextSection> expandedSections = getInitiallyExpanded(_textSections);
-        for (final Map.Entry<? extends Object, XMLTextSection> entry : _textSections
-                .entrySet())
-        {
-            final XMLTextSection section = entry.getValue();
-            if (expandedSections.contains(section))
-            {
-                section._section.setExpanded(true);
-            }
-        }
-    }
-
-    /**
-     * @param parent
-     *            the parent that should be used for all XMLTextSections
-     * @return a map keyed by an object type understood by the sub-class
-     *         containing as values the XMLTextSections
-     */
-    protected abstract Map<? extends Object, XMLTextSection> createXMLTextSections(
-            final Composite parent);
-
-    /**
-     * @param sections
-     * @return the subset of XMLTextSections in the provided map that are to be
-     *         expanded. NOTE: all elements in the returned set must be in
-     *         sections.getValues.
-     */
-    protected abstract Set<XMLTextSection> getInitiallyExpanded(
-            final Map<Object, XMLTextSection> sections);
-
-    /**
-     * @return the control for this form
-     */
-    @Override
-    public Control getControl()
-    {
-        return _detailFormComposite;
-    }
-
-    /**
-     * @param selection
-     */
-    public final void selectionChanged(final ISelection selection)
-    {
-        if (selection instanceof IStructuredSelection)
-        {
-            final Object selectionObj = ((IStructuredSelection) selection)
-                    .getFirstElement();
-            doUpdateSelection(selectionObj);
-        }
-    }
-
-    @Override
-    public void commit(final boolean onSave)
-    {
-        // do nothing
-    }
-
-    @Override
-    public void dispose()
-    {
-        // do nothing
-    }
-
-    @Override
-    public void setFocus()
-    {
-        // do nothing; sub-classes should override to pick an XMLTextSection
-        // where they want focus.
-    }
-
-    /**
-     * An XML text section
-     * 
-     */
-    protected final static class XMLTextSection
-    {
-        private final Section _section;
-        private FormText      _formText;
-
-        /**
-         * @param toolkit
-         * @param parent
-         * @param title
-         */
-        public XMLTextSection(final FormToolkit toolkit,
-                final Composite parent, final String title)
-        {
-            _section = toolkit.createSection(parent,
-                    ExpandableComposite.TREE_NODE
-                            | ExpandableComposite.CLIENT_INDENT);
-            _section.setLayoutData(new RowData());
-            _section.setText(title);
-
-            _formText = toolkit.createFormText(_section, true);
-            _formText.setText("", false, false); //$NON-NLS-1$
-
-            _section.setClient(_formText);
-        }
-
-        /**
-         * @param text
-         * @param parseTags
-         * @param expandURLs
-         */
-        public void setText(final String text, final boolean parseTags,
-                final boolean expandURLs)
-        {
-            _formText.setText(text, parseTags, expandURLs);
-        }
-
-        /**
-         * @return the parent control.
-         */
-        public Control getControl()
-        {
-            return _section;
-        }
-
-        /**
-         * Force a visual relayout and update.
-         */
-        public void refresh()
-        {
-            _section.getParent().layout(true, true);
-        }
-    }
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/form/BlankDetailsForm.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/form/BlankDetailsForm.java
deleted file mode 100644
index 7678b03..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/form/BlankDetailsForm.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.form;
-
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-
-/**
- * A blank details form.
- * 
- * @author cbateman
- * 
- */
-public final class BlankDetailsForm extends AbstractDetailsForm
-{
-    private Composite _emptyPanel;
-
-    @Override
-    public void createContents(Composite parent)
-    {
-        _emptyPanel = getToolkit().createComposite(parent);
-    }
-
-    @Override
-    public Control getControl()
-    {
-        return _emptyPanel;
-    }
-
-    @Override
-    protected void doUpdateSelection(Object newSelection)
-    {
-        // do nothing
-    }
-
-    @Override
-    public void commit(boolean onSave)
-    {
-        // nothing to commit
-    }
-
-    @Override
-    public void dispose()
-    {
-       // nothing to dispose
-    }
-
-    @Override
-    public void setFocus()
-    {
-        // don't bother changing focus
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/Alerts.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/Alerts.java
deleted file mode 100644
index 54c3a27..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/Alerts.java
+++ /dev/null
@@ -1,837 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.guiutils;
-
-import java.lang.reflect.InvocationTargetException;
-import java.text.MessageFormat;
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
-
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.MultiStatus;
-import org.eclipse.core.runtime.Status;
-import org.eclipse.jface.dialogs.ErrorDialog;
-import org.eclipse.jface.dialogs.IInputValidator;
-import org.eclipse.jface.dialogs.InputDialog;
-import org.eclipse.jface.dialogs.MessageDialog;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.swt.widgets.Shell;
-import org.eclipse.ui.PlatformUI;
-import org.eclipse.ui.plugin.AbstractUIPlugin;
-
-/**
- * This class will provide UI alert dialogs to the user. These will
- * automatically get the message from the plugin's resource bundle.
- * 
- * NOTE: there are some generic exception methods included in this file. They
- * need resource bundles also, and they make the alerts bettern when the
- * exception is caught at a later stage.
- * 
- * @author mengbo
- */
-public class Alerts {
-	// this is used for junit testing to turn off all alerts and return the
-	// default on yes/no dialogs.
-	private static boolean _noAlerts = false;
-
-	private ResourceBundle _rb;
-
-	private String _pluginId;
-
-	/**
-	 * Construct a alerts with the provided attributes. This constructor should
-	 * be used from the root plugin that has access to the resource bundle for
-	 * this plugin.
-	 * 
-	 * @param plugin 
-	 * @param rb
-	 *            the resource bundle to use.
-	 */
-	public Alerts(AbstractUIPlugin plugin, ResourceBundle rb) {
-		_rb = rb;
-		if (_rb == null) {
-			throw new NullPointerException(
-					"No resource bundle was provided to the Alerts."); //$NON-NLS-1$
-		}
-		if (plugin == null) {
-			throw new NullPointerException(
-					"No plugin was provided to the Alerts."); //$NON-NLS-1$
-		}
-		_pluginId = plugin.getBundle().getSymbolicName();
-	}
-
-	/**
-	 * Returns the text entered by a user in a simple request dialog.
-	 * 
-	 * @param titleKey -
-	 *            the title resource bundle key for the message
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 * @param initialValue -
-	 *            initial value in the text area.
-	 * @param validator -
-	 *            something that checks for validity on the name.
-	 * @return null is returned if the user hits cancel, otherwise it is the
-	 *         text they entered.
-	 */
-	public String getInput(String titleKey, String msgKey, String initialValue,
-			IInputValidator validator) {
-		if (_noAlerts) {
-			return null;
-		}
-
-		InputDialog inDialog = new InputDialog(PlatformUI.getWorkbench()
-				.getActiveWorkbenchWindow().getShell(),
-				getResourceString(titleKey), getResourceString(msgKey),
-				initialValue, validator);
-		inDialog.open();
-		return inDialog.getValue();
-	}
-
-	/**
-	 * Displays an Error message to the user.
-	 * 
-	 * @param titleKey -
-	 *            the title resource bundle key for the message
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 */
-	public void error(String titleKey, String msgKey) {
-		if (_noAlerts) {
-			return;
-		}
-
-		MessageDialog.openError(PlatformUI.getWorkbench()
-				.getActiveWorkbenchWindow().getShell(),
-				getResourceString(titleKey), getResourceString(msgKey));
-	}
-
-	/**
-	 * Displays an Error message to the user.
-	 * 
-	 * @param titleKey -
-	 *            the title resource bundle key for the message
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 * @param arg0 -
-	 *            arg to place into the resource bundle message.
-	 */
-	public void error(String titleKey, String msgKey, Object arg0) {
-		if (_noAlerts) {
-			return;
-		}
-
-		Object[] args = new Object[1];
-		args[0] = arg0;
-
-		MessageFormat formatter = new MessageFormat(getResourceString(msgKey));
-
-		MessageDialog.openError(PlatformUI.getWorkbench()
-				.getActiveWorkbenchWindow().getShell(),
-				getResourceString(titleKey), formatter.format(args));
-	}
-
-	/**
-	 * Displays an Error message to the user.
-	 * 
-	 * @param titleKey -
-	 *            the title resource bundle key for the message
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 * @param arg0 -
-	 *            arg to place into the resource bundle message.
-	 * @param arg1 -
-	 *            arg to place into the resource bundle message.
-	 */
-	public void error(String titleKey, String msgKey, Object arg0, Object arg1) {
-		if (_noAlerts) {
-			return;
-		}
-
-		Object[] args = new Object[2];
-		args[0] = arg0;
-		args[1] = arg1;
-
-		MessageFormat formatter = new MessageFormat(getResourceString(msgKey));
-
-		MessageDialog.openError(PlatformUI.getWorkbench()
-				.getActiveWorkbenchWindow().getShell(),
-				getResourceString(titleKey), formatter.format(args));
-	}
-
-	/**
-	 * Displays an Error message to the user.
-	 * 
-	 * @param titleKey -
-	 *            the title resource bundle key for the message
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 * @param arg0 -
-	 *            arg to place into the resource bundle message.
-	 * @param arg1 -
-	 *            arg to place into the resource bundle message.
-	 * @param arg2 -
-	 *            arg to place into the resource bundle message.
-	 */
-	public void error(String titleKey, String msgKey, Object arg0, Object arg1,
-			Object arg2) {
-		if (_noAlerts) {
-			return;
-		}
-
-		Object[] args = new Object[3];
-		args[0] = arg0;
-		args[1] = arg1;
-		args[2] = arg2;
-
-		MessageFormat formatter = new MessageFormat(getResourceString(msgKey));
-
-		MessageDialog.openError(PlatformUI.getWorkbench()
-				.getActiveWorkbenchWindow().getShell(),
-				getResourceString(titleKey), formatter.format(args));
-	}
-
-	/**
-	 * Displays an Error message to the user.
-	 * 
-	 * @param titleKey -
-	 *            the title resource bundle key for the message
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 * @param arg0 -
-	 *            arg to place into the resource bundle message.
-	 * @param arg1 -
-	 *            arg to place into the resource bundle message.
-	 * @param arg2 -
-	 *            arg to place into the resource bundle message.
-	 * @param arg3 -
-	 *            arg to place into the resource bundle message.
-	 */
-	public void error(String titleKey, String msgKey, Object arg0, Object arg1,
-			Object arg2, Object arg3) {
-		if (_noAlerts) {
-			return;
-		}
-
-		Object[] args = new Object[4];
-		args[0] = arg0;
-		args[1] = arg1;
-		args[2] = arg2;
-		args[3] = arg3;
-
-		MessageFormat formatter = new MessageFormat(getResourceString(msgKey));
-
-		MessageDialog.openError(PlatformUI.getWorkbench()
-				.getActiveWorkbenchWindow().getShell(),
-				getResourceString(titleKey), formatter.format(args));
-	}
-
-	/**
-	 * Displays an Error message to the user.
-	 * 
-	 * @param shell -
-	 *            the shell for the error dialog
-	 * @param titleKey -
-	 *            the title resource bundle key for the message
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 */
-	public void error(Shell shell, String titleKey, String msgKey) {
-		if (_noAlerts) {
-			return;
-		}
-
-		MessageDialog.openError(shell, getResourceString(titleKey),
-				getResourceString(msgKey));
-	}
-
-	/**
-	 * Displays an Error message to the user with a status using the Display
-	 * background thread.
-	 * 
-	 * @param titleKey -
-	 *            the title resource bundle key for the message
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 */
-	public void detailError(String titleKey, String msgKey) {
-		if (_noAlerts) {
-			return;
-		}
-
-		final IStatus fstatus = new Status(IStatus.ERROR, _pluginId,
-				IStatus.OK, getResourceString(msgKey), null);
-		final String ftitle = getResourceString(titleKey);
-
-		Display display = getStandardDisplay();
-		display.asyncExec(new Runnable() {
-			public void run() {
-				ErrorDialog.openError(null, ftitle, null, fstatus);
-			}
-		});
-	}
-
-	/**
-	 * Displays an Error message to the user with a status using the Display
-	 * background thread. This will give the details button.
-	 * 
-	 * @param titleKey -
-	 *            the title resource bundle key for the message
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 * @param tt -
-	 *            exception to place in the details.
-	 */
-	public void detailError(String titleKey, String msgKey, Throwable tt) {
-		if (_noAlerts) {
-			return;
-		}
-
-		internalDetailError(getResourceString(titleKey),
-				getResourceString(msgKey), tt);
-	}
-
-	/**
-	 * Displays an Error message to the user with a status using the Display
-	 * background thread. This will give the details button.
-	 * 
-	 * @param titleKey -
-	 *            the title resource bundle key for the message
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 * @param arg0 -
-	 *            arg to place into the resource bundle message.
-	 * @param tt -
-	 *            exception to place in the details.
-	 */
-	public void detailError(String titleKey, String msgKey, Object arg0,
-			Throwable tt) {
-		if (_noAlerts) {
-			return;
-		}
-
-		Object[] args = new Object[1];
-		args[0] = arg0;
-
-		MessageFormat formatter = new MessageFormat(getResourceString(msgKey));
-
-		internalDetailError(getResourceString(titleKey),
-				formatter.format(args), tt);
-	}
-
-	/**
-	 * Displays an Error message to the user with a status using the Display
-	 * background thread. This will give the details button.
-	 * 
-	 * @param titleKey -
-	 *            the title resource bundle key for the message
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 * @param arg0 -
-	 *            arg to place into the resource bundle message.
-	 * @param arg1 -
-	 *            arg to place into the resource bundle message.
-	 * @param tt -
-	 *            exception to place in the details.
-	 */
-	public void detailError(String titleKey, String msgKey, Object arg0,
-			Object arg1, Throwable tt) {
-		if (_noAlerts) {
-			return;
-		}
-
-		Object[] args = new Object[1];
-		args[0] = arg0;
-		args[1] = arg1;
-
-		MessageFormat formatter = new MessageFormat(getResourceString(msgKey));
-
-		internalDetailError(getResourceString(titleKey),
-				formatter.format(args), tt);
-	}
-
-	/**
-	 * Displays an Error message to the user with a status using the Display
-	 * background thread. This will give the details button.
-	 * 
-	 * @param title -
-	 *            the title message
-	 * @param message -
-	 *            message displayed to the user
-	 */
-	private void internalDetailError(String title, String msg, Throwable tt) {
-		if (_noAlerts) {
-			return;
-		}
-
-		if (tt instanceof InvocationTargetException) {
-			tt = ((InvocationTargetException) tt).getTargetException();
-		}
-
-		IStatus status = null;
-		if (tt instanceof CoreException) {
-			status = ((CoreException) tt).getStatus();
-
-			if ((status instanceof MultiStatus) == false) {
-				// convert to a multistatus to show the exception details.
-
-				Throwable th = status.getException();
-				if (th == null) {
-					th = tt;
-				}
-
-				status = buildStackTraceStatus(IStatus.ERROR, status
-						.getPlugin(), status.getMessage(), th);
-			}
-		} else {
-			status = buildStackTraceStatus(IStatus.ERROR, _pluginId, tt
-					.getMessage(), tt);
-		}
-
-		final String ftitle = title;
-		final IStatus fstatus = status;
-		final String fmsg = msg;
-		Display display = getStandardDisplay();
-		display.asyncExec(new Runnable() {
-			public void run() {
-				ErrorDialog.openError(null, ftitle, fmsg, fstatus);
-			}
-		});
-	}
-
-	/**
-	 * Builds a multistatus, so that the stack trace shows up in the alery
-	 * message for detailed alerts.
-	 * 
-	 * @param code
-	 * @param pluginId
-	 * @param message
-	 * @param tt
-	 * @return the result of the operation
-	 */
-	public IStatus buildStackTraceStatus(int code, String pluginId,
-			String message, Throwable tt) {
-		if (tt == null) {
-			return new Status(code, pluginId, IStatus.OK, message, tt);
-		}
-
-		MultiStatus mstat = new MultiStatus(pluginId, code, message, tt);
-
-		StackTraceElement[] trace = tt.getStackTrace();
-
-		mstat.add(new Status(code, pluginId, IStatus.OK, tt.toString(), null));
-		for (int ii = 0; ii < trace.length; ii++) {
-			mstat.add(new Status(code, pluginId, IStatus.OK, trace[ii]
-					.toString(), null));
-		}
-		return mstat;
-	}
-
-	/**
-	 * Displays an Error message to the user with a status using the Display
-	 * background thread. This will give the details button.
-	 * 
-	 * @param status -
-	 *            the status
-	 * @param title -
-	 *            the title of the message
-	 */
-	public void detailError(String title, IStatus status) {
-		if (_noAlerts) {
-			return;
-		}
-
-		final IStatus fstatus = status;
-		final String ftitle = title;
-		Display display = getStandardDisplay();
-		display.asyncExec(new Runnable() {
-			public void run() {
-				ErrorDialog.openError(null, ftitle, null, fstatus);
-			}
-		});
-	}
-
-	/**
-	 * Displays an information message to the user.
-	 * 
-	 * @param titleKey -
-	 *            the title resource bundle key for the message
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 */
-	public void info(String titleKey, String msgKey) {
-		if (_noAlerts) {
-			return;
-		}
-
-		MessageDialog.openInformation(PlatformUI.getWorkbench()
-				.getActiveWorkbenchWindow().getShell(),
-				getResourceString(titleKey), getResourceString(msgKey));
-	}
-
-	/**
-	 * Displays an information message to the user.
-	 * 
-	 * @param titleKey -
-	 *            the title resource bundle key for the message
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 * @param arg0 -
-	 *            arg to place into the resource bundle message.
-	 */
-	public void info(String titleKey, String msgKey, Object arg0) {
-		if (_noAlerts) {
-			return;
-		}
-
-		Object[] args = new Object[1];
-		args[0] = arg0;
-
-		MessageFormat formatter = new MessageFormat(getResourceString(msgKey));
-
-		MessageDialog.openInformation(PlatformUI.getWorkbench()
-				.getActiveWorkbenchWindow().getShell(),
-				getResourceString(titleKey), formatter.format(args));
-	}
-
-	/**
-	 * Displays an confirmation message to the user.
-	 * 
-	 * @param titleKey -
-	 *            the title resource bundle key for the message
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 * @return true if the user presses the OK button, false otherwise
-	 */
-	public boolean confirm(String titleKey, String msgKey) {
-		if (_noAlerts) {
-			return true;
-		}
-
-		return MessageDialog.openConfirm(PlatformUI.getWorkbench()
-				.getActiveWorkbenchWindow().getShell(),
-				getResourceString(titleKey), getResourceString(msgKey));
-	}
-
-	/**
-	 * Displays an confirmation message to the user.
-	 * 
-	 * @param titleKey -
-	 *            the title resource bundle key for the message
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 * @param arg0 -
-	 *            arg to place into the resource bundle message.
-	 * @return true if the user presses the OK button, false otherwise
-	 */
-	public boolean confirm(String titleKey, String msgKey, Object arg0) {
-		if (_noAlerts) {
-			return true;
-		}
-
-		Object[] args = new Object[1];
-		args[0] = arg0;
-
-		MessageFormat formatter = new MessageFormat(getResourceString(msgKey));
-
-		return MessageDialog.openConfirm(PlatformUI.getWorkbench()
-				.getActiveWorkbenchWindow().getShell(),
-				getResourceString(titleKey), formatter.format(args));
-	}
-
-	/**
-	 * Displays an question message to the user.
-	 * 
-	 * @param titleKey -
-	 *            the title resource bundle key for the message
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 * @return true if the user presses the "yes" button, false otherwise
-	 */
-	public boolean question(String titleKey, String msgKey) {
-		if (_noAlerts) {
-			return true;
-		}
-
-		return MessageDialog.openQuestion(PlatformUI.getWorkbench()
-				.getActiveWorkbenchWindow().getShell(),
-				getResourceString(titleKey), getResourceString(msgKey));
-	}
-
-	/**
-	 * Displays an question message to the user.
-	 * 
-	 * @param titleKey -
-	 *            the title resource bundle key for the message
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 * @param arg0 -
-	 *            arg to place into the resource bundle message.
-	 * @return true if the user presses the "yes" button, false otherwise
-	 */
-	public boolean question(String titleKey, String msgKey, Object arg0) {
-		if (_noAlerts) {
-			return true;
-		}
-
-		Object[] args = new Object[1];
-		args[0] = arg0;
-
-		MessageFormat formatter = new MessageFormat(getResourceString(msgKey));
-
-		return MessageDialog.openQuestion(PlatformUI.getWorkbench()
-				.getActiveWorkbenchWindow().getShell(),
-				getResourceString(titleKey), formatter.format(args));
-	}
-
-	/**
-	 * Displays an warning message to the user.
-	 * 
-	 * @param titleKey -
-	 *            the title resource bundle key for the message
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 */
-	public void warning(String titleKey, String msgKey) {
-		if (_noAlerts) {
-			return;
-		}
-
-		MessageDialog.openWarning(PlatformUI.getWorkbench()
-				.getActiveWorkbenchWindow().getShell(),
-				getResourceString(titleKey), getResourceString(msgKey));
-	}
-
-	/**
-	 * Displays an warning message to the user.
-	 * 
-	 * @param titleKey -
-	 *            the title resource bundle key for the message
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 * @param arg0 -
-	 *            arg to place into the resource bundle message.
-	 */
-	public void warning(String titleKey, String msgKey, Object arg0) {
-		if (_noAlerts) {
-			return;
-		}
-
-		Object[] args = new Object[1];
-		args[0] = arg0;
-
-		MessageFormat formatter = new MessageFormat(getResourceString(msgKey));
-
-		MessageDialog.openWarning(PlatformUI.getWorkbench()
-				.getActiveWorkbenchWindow().getShell(),
-				getResourceString(titleKey), formatter.format(args));
-	}
-
-	/**
-	 * Returns the standard display to be used. The method first checks, if the
-	 * thread calling this method has an associated dispaly. If so, this display
-	 * is returned. Otherwise the method returns the default display.
-	 * 
-	 * TODO: should probably use the workbench display
-	 */
-	private Display getStandardDisplay() {
-		Display display = Display.getCurrent();
-		if (display == null) {
-			display = Display.getDefault();
-		}
-		return display;
-	}
-
-	/**
-	 * Returns the string from the resource bundle, or 'key' if not found.
-	 */
-	private String getResourceString(String key) {
-		if (key == null) {
-			return null;
-		}
-
-		try {
-			return _rb.getString(key);
-		} catch (MissingResourceException ee) {
-			return key;
-		}
-	}
-
-	/**
-	 * Throw a core exception built around the message with the correct plugin
-	 * id and resource bundle string.
-	 * 
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 * @throws CoreException
-	 */
-	public void throwCoreException(String msgKey) throws CoreException {
-		IStatus status = new Status(IStatus.ERROR, _pluginId, IStatus.OK,
-				getResourceString(msgKey), null);
-		throw new CoreException(status);
-	}
-
-	/**
-	 * Throw a core exception built around the message with the correct plugin
-	 * id and resource bundle string.
-	 * 
-	 * @param ee -
-	 *            the real exception.
-	 * @throws CoreException
-	 */
-	public void throwCoreException(Throwable ee) throws CoreException {
-		IStatus status = new Status(IStatus.ERROR, _pluginId, IStatus.OK, ee
-				.getMessage(), ee);
-		throw new CoreException(status);
-	}
-
-	/**
-	 * Throw a core exception built around the message with the correct plugin
-	 * id and resource bundle string.
-	 * 
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 * @param ee -
-	 *            the real exception.
-	 * @throws CoreException
-	 */
-	public void throwCoreException(String msgKey, Throwable ee)
-			throws CoreException {
-		IStatus status = new Status(IStatus.ERROR, _pluginId, IStatus.OK,
-				getResourceString(msgKey), ee);
-		throw new CoreException(status);
-	}
-
-	/**
-	 * Throw a core exception built around the message with the correct plugin
-	 * id and resource bundle string.
-	 * 
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 * @param arg0 -
-	 *            arg to place into the resource bundle message.
-	 * @throws CoreException
-	 */
-	public void throwCoreException(String msgKey, Object arg0)
-			throws CoreException {
-		Object[] args = new Object[1];
-		args[0] = arg0;
-
-		MessageFormat formatter = new MessageFormat(getResourceString(msgKey));
-
-		IStatus status = new Status(IStatus.ERROR, _pluginId, IStatus.OK,
-				formatter.format(args), null);
-		throw new CoreException(status);
-	}
-
-	/**
-	 * Throw a core exception built around the message with the correct plugin
-	 * id and resource bundle string.
-	 * 
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 * @param arg0 -
-	 *            arg to place into the resource bundle message.
-	 * @param ee -
-	 *            the real exception.
-	 * @throws CoreException
-	 */
-	public void throwCoreException(String msgKey, Object arg0, Throwable ee)
-			throws CoreException {
-		Object[] args = new Object[1];
-		args[0] = arg0;
-
-		MessageFormat formatter = new MessageFormat(getResourceString(msgKey));
-
-		IStatus status = new Status(IStatus.ERROR, _pluginId, IStatus.OK,
-				formatter.format(args), ee);
-		throw new CoreException(status);
-	}
-
-	/**
-	 * Throw a core exception built around the message with the correct plugin
-	 * id and resource bundle string.
-	 * 
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 * @param arg0 -
-	 *            arg to place into the resource bundle message.
-	 * @param arg1 -
-	 *            arg to place into the resource bundle message.
-	 * @throws CoreException
-	 */
-	public void throwCoreException(String msgKey, Object arg0, Object arg1)
-			throws CoreException {
-		Object[] args = new Object[2];
-		args[0] = arg0;
-		args[1] = arg1;
-
-		MessageFormat formatter = new MessageFormat(getResourceString(msgKey));
-
-		IStatus status = new Status(IStatus.ERROR, _pluginId, IStatus.OK,
-				formatter.format(args), null);
-		throw new CoreException(status);
-	}
-
-	/**
-	 * Throw a core exception built around the message with the correct plugin
-	 * id and resource bundle string.
-	 * 
-	 * @param msgKey -
-	 *            message resource bundle key for the message displayed to the
-	 *            user
-	 * @param arg0 -
-	 *            arg to place into the resource bundle message.
-	 * @param arg1 -
-	 *            arg to place into the resource bundle message.
-	 * @param ee -
-	 *            the real exception.
-	 * @throws CoreException
-	 */
-	public void throwCoreException(String msgKey, Object arg0, Object arg1,
-			Throwable ee) throws CoreException {
-		Object[] args = new Object[2];
-		args[0] = arg0;
-		args[1] = arg1;
-
-		MessageFormat formatter = new MessageFormat(getResourceString(msgKey));
-
-		IStatus status = new Status(IStatus.ERROR, _pluginId, IStatus.OK,
-				formatter.format(args), ee);
-		throw new CoreException(status);
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/BrowserWindow.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/BrowserWindow.java
deleted file mode 100644
index 33ce9fa..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/BrowserWindow.java
+++ /dev/null
@@ -1,391 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.guiutils;
-
-import org.eclipse.jface.window.ApplicationWindow;
-import org.eclipse.jst.jsf.common.ui.JSFUICommonPlugin;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.browser.Browser;
-import org.eclipse.swt.browser.LocationAdapter;
-import org.eclipse.swt.browser.LocationEvent;
-import org.eclipse.swt.browser.OpenWindowListener;
-import org.eclipse.swt.browser.StatusTextEvent;
-import org.eclipse.swt.browser.StatusTextListener;
-import org.eclipse.swt.browser.WindowEvent;
-import org.eclipse.swt.custom.ScrolledComposite;
-import org.eclipse.swt.events.ControlAdapter;
-import org.eclipse.swt.events.ControlEvent;
-import org.eclipse.swt.events.ControlListener;
-import org.eclipse.swt.events.SelectionAdapter;
-import org.eclipse.swt.events.SelectionEvent;
-import org.eclipse.swt.events.SelectionListener;
-import org.eclipse.swt.graphics.Point;
-import org.eclipse.swt.graphics.Rectangle;
-import org.eclipse.swt.layout.FillLayout;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Shell;
-import org.eclipse.swt.widgets.ToolBar;
-import org.eclipse.swt.widgets.ToolItem;
-
-/**
- * Brings up a browser into a separate window.
- * 
- * @author mengbo.  
- * 
- * Unused???
- */
-public class BrowserWindow extends ApplicationWindow {
-
-	private static final String RELOAD_ITEM_IMAGE_FILE = "reload_nav_16.gif"; //$NON-NLS-1$
-
-	private static final String REFRESH_ITEM_IMAGE_FILE = "refresh_nav_16.gif"; //$NON-NLS-1$
-
-	private static final String STOP_ITEM_IMAGE_FILE = "stop_nav_16.gif"; //$NON-NLS-1$
-
-	private static final String FORWARD_ITEM_IMAGE_FILE = "forward_nav_16.gif"; //$NON-NLS-1$
-
-	private static final String BACK_ITEM_IMAGE_FILE = "back_nav_16.gif"; //$NON-NLS-1$
-
-	
-	/**
-	 * Command to send to the browser.
-	 */
-	private static final int BROWSER_CMD_BACK = 1;
-
-	private static final int BROWSER_CMD_FORWARD = 2;
-
-	private static final int BROWSER_CMD_STOP = 3;
-
-	private static final int BROWSER_CMD_REFRESH = 4;
-
-	private static final int BROWSER_CMD_RELOAD = 5;
-
-	private boolean _bIncludeToolbar;
-
-	private boolean _bPopups;
-
-	private String _title;
-
-	private ScrolledComposite _scomp;
-
-	private Composite _browserComposite;
-
-	private Browser _browser;
-
-	private String _startLocation;
-
-	private String _startContent;
-
-	// these items are browser context sensitive.
-	private ToolItem _backItem;
-
-	private ToolItem _forwardItem;
-
-	/**
-	 * @param parentShell
-	 *            owner of this window.
-	 */
-	public BrowserWindow(Shell parentShell) {
-		this(parentShell, false, null, false);
-	}
-
-	/**
-	 * @param parentShell
-	 *            owner of this window.
-	 * @param bPopups
-	 *            allow popup windows?
-	 * @param title
-	 *            Tittle on window.
-	 */
-	public BrowserWindow(Shell parentShell, boolean bPopups, String title) {
-		this(parentShell, bPopups, title, false);
-	}
-
-	/**
-	 * @param parentShell
-	 *            owner of this window.
-	 * @param bPopups
-	 *            allow popup windows?
-	 * @param title
-	 *            Tittle on window.
-	 * @param bModal
-	 *            pretend to a be a dialog?
-	 */
-	public BrowserWindow(Shell parentShell, boolean bPopups, String title,
-			boolean bModal) {
-		super(parentShell);
-		addStatusLine();
-		_bPopups = bPopups;
-		_title = title;
-		includeToolbar(true);
-
-		if (bModal && (parentShell != null)) {
-			// APPLICATION_MODAL, MODELESS, PRIMARY_MODAL, SYSTEM_MODAL
-			setShellStyle(getShellStyle() | SWT.APPLICATION_MODAL);
-			setBlockOnOpen(true);
-		}
-	}
-
-	/**
-	 * Default is true, set whether to include the toolbar at the top. This must
-	 * be called before the window is opened.
-	 * 
-	 * @param bIncludeToolbar
-	 */
-	public void includeToolbar(boolean bIncludeToolbar) {
-		_bIncludeToolbar = bIncludeToolbar;
-	}
-
-	/**
-	 * @param title
-	 */
-	public void setTitle(String title) {
-		if ((title != null) && (super.getShell() != null)) {
-			super.getShell().setText(title);
-		}
-	}
-
-	/**
-	 * @param startLocation
-	 */
-	/**
-	 * @param startLocation
-	 */
-	public void setStartLocation(String startLocation) {
-		_startLocation = startLocation;
-	}
-
-	/**
-	 * @param startContent
-	 */
-	public void setStartContent(String startContent) {
-		_startContent = startContent;
-	}
-
-	/**
-	 * @return the browser object
-	 */
-	public Browser getBrowser() {
-		return _browser;
-	}
-
-	protected Control createContents(Composite parent) {
-		// Create the scroll composite as the one inside the parent.
-		_scomp = new ScrolledComposite(parent, SWT.V_SCROLL | SWT.H_SCROLL);
-
-		// Create the composite that goes inside the scroller. We will use this
-		// for
-		// everything else from here.
-		Composite innerComposite = SWTUtils.createComposite(_scomp, 1, 10, -1);
-		_scomp.setContent(innerComposite);
-		ControlListener listener = new ControlAdapter() {
-			// this will handle resizing the browser when the window is resized.
-			public void controlResized(ControlEvent e) {
-				Point pt = _scomp.getParent().getSize();
-				Rectangle rect = _browserComposite.getBounds();
-
-				pt.x -= rect.x;
-				pt.y -= rect.y;
-
-				// spacing offsets in the composites.
-				pt.x -= 10;
-				pt.y -= 60; // need status bar at bottom...30 more than normal.
-
-				// do the sanity check here since it prevents further checks.
-				if ((pt.x <= 0) || (pt.y <= 0)) {
-					return;
-				}
-
-				Rectangle innerRect = _scomp.getContent().getBounds();
-				Rectangle outerRect = _scomp.getBounds();
-
-				// substract if the scroll bars are visible.
-				if (innerRect.width > outerRect.width) {
-					pt.y -= _scomp.getHorizontalBar().getSize().y;
-				}
-				if (innerRect.height > outerRect.height) {
-					pt.x -= _scomp.getVerticalBar().getSize().x;
-				}
-
-				_browserComposite.setSize(pt);
-				_browserComposite.getParent().layout(true);
-			}
-		};
-		_scomp.addControlListener(listener);
-
-		if (_bIncludeToolbar) {
-			// ////////////////////////////////////////
-			// toobar
-			// ////////////////////////////////////////
-			ToolBar tb = new ToolBar(innerComposite, SWT.HORIZONTAL | SWT.FLAT);
-			fillToolbar(tb);
-		}
-
-		// ////////////////////////////////////////
-		// browser
-		// ////////////////////////////////////////
-		_browserComposite = new Composite(innerComposite, SWT.NULL);
-		_browserComposite.setLayout(new FillLayout());
-
-		_browser = new Browser(_browserComposite, SWT.NULL);
-
-		if (_startLocation != null) {
-			_browser.setUrl(_startLocation);
-		} else if (_startContent != null) {
-			_browser.setText(_startContent);
-		} else {
-			_browser.setText(Messages.BrowserWindow_loading);
-		}
-
-		// send the browser status messages to eclipse.
-		_browser.addStatusTextListener(new StatusTextListener() {
-			public void changed(StatusTextEvent event) {
-				setStatus(event.text);
-			}
-		});
-
-		if (_bIncludeToolbar) {
-			// check for change in location so we can enable the back/forward
-			// buttons.
-			_browser.addLocationListener(new LocationAdapter() {
-				public void changed(LocationEvent event) {
-					// check if there is something in the forward or back queue.
-					_backItem.setEnabled(_browser.isBackEnabled());
-					_forwardItem.setEnabled(_browser.isForwardEnabled());
-				}
-			});
-		}
-
-		// check is we need to open a new window.
-		_browser.addOpenWindowListener(new OpenWindowListener() {
-			public void open(WindowEvent event) {
-				if (_bPopups) {
-					BrowserWindow window = new BrowserWindow(getShell());
-					window.open();
-					event.browser = window.getBrowser();
-				} else {
-					event.browser = getBrowser();
-				}
-			}
-		});
-
-		setTitle(_title);
-		SWTUtils.computeScrollArea(_scomp, innerComposite);
-		return _scomp;
-	}
-
-	/**
-	 * Fill the toolbar for this window. This method can be overwritten to place
-	 * other toolbar controls in the bar.
-	 * 
-	 * @param tb
-	 */
-	protected void fillToolbar(ToolBar tb) {
-		// Back browser
-		_backItem = new ToolItem(tb, SWT.PUSH);
-		_backItem.setImage(JSFUICommonPlugin.getDefault()
-				.getImage(BACK_ITEM_IMAGE_FILE));
-		_backItem.setToolTipText(JSFUICommonPlugin
-				.getResourceString("BrowserWindow.back.tooltip")); //$NON-NLS-1$
-		SelectionListener backSelectionListener = new SelectionAdapter() {
-			public void widgetSelected(SelectionEvent event) {
-				browserCmd(BROWSER_CMD_BACK);
-			}
-		};
-		_backItem.addSelectionListener(backSelectionListener);
-
-		// Forward Browser
-		_forwardItem = new ToolItem(tb, SWT.PUSH);
-		_forwardItem.setImage(JSFUICommonPlugin.getDefault().getImage(
-				FORWARD_ITEM_IMAGE_FILE));
-		_forwardItem.setToolTipText(JSFUICommonPlugin
-				.getResourceString("BrowserWindow.forward.tooltip")); //$NON-NLS-1$
-		SelectionListener forwardSelectionListener = new SelectionAdapter() {
-			public void widgetSelected(SelectionEvent event) {
-				browserCmd(BROWSER_CMD_FORWARD);
-			}
-		};
-		_forwardItem.addSelectionListener(forwardSelectionListener);
-
-		// Stop Browser
-		ToolItem stopItem = new ToolItem(tb, SWT.PUSH);
-		stopItem
-				.setImage(JSFUICommonPlugin.getDefault().getImage(STOP_ITEM_IMAGE_FILE));
-		stopItem.setToolTipText(JSFUICommonPlugin
-				.getResourceString("BrowserWindow.stop.tooltip")); //$NON-NLS-1$
-		SelectionListener stopSelectionListener = new SelectionAdapter() {
-			public void widgetSelected(SelectionEvent event) {
-				browserCmd(BROWSER_CMD_STOP);
-			}
-		};
-		stopItem.addSelectionListener(stopSelectionListener);
-
-		// Refresh Browser
-		ToolItem refreshItem = new ToolItem(tb, SWT.PUSH);
-		refreshItem.setImage(JSFUICommonPlugin.getDefault().getImage(
-				REFRESH_ITEM_IMAGE_FILE));
-		refreshItem.setToolTipText(JSFUICommonPlugin
-				.getResourceString("BrowserWindow.refresh.tooltip")); //$NON-NLS-1$
-		SelectionListener refreshServiceSelectionListener = new SelectionAdapter() {
-			public void widgetSelected(SelectionEvent event) {
-				browserCmd(BROWSER_CMD_REFRESH);
-			}
-		};
-		refreshItem.addSelectionListener(refreshServiceSelectionListener);
-
-		if ((_startLocation != null) || (_startContent != null)) {
-			// Reload Browser.
-			ToolItem reloadItem = new ToolItem(tb, SWT.PUSH);
-			reloadItem.setImage(JSFUICommonPlugin.getDefault().getImage(
-					RELOAD_ITEM_IMAGE_FILE));
-			reloadItem.setToolTipText(JSFUICommonPlugin
-					.getResourceString("BrowserWindow.reload.tooltip")); //$NON-NLS-1$
-			SelectionListener reloadSelectionListener = new SelectionAdapter() {
-				public void widgetSelected(SelectionEvent event) {
-					browserCmd(BROWSER_CMD_RELOAD);
-				}
-			};
-			reloadItem.addSelectionListener(reloadSelectionListener);
-		}
-	}
-
-	/**
-	 * send the browser widget a command as defined by the cmd constant defines.
-	 * @param cmd
-	 * 
-	 * @return true if the command was successful.
-	 */
-	public boolean browserCmd(int cmd) {
-		switch (cmd) {
-		case BROWSER_CMD_BACK:
-			return _browser.back();
-		case BROWSER_CMD_FORWARD:
-			return _browser.forward();
-		case BROWSER_CMD_STOP:
-			_browser.stop();
-			return true;
-		case BROWSER_CMD_REFRESH:
-			_browser.refresh();
-			return true;
-		case BROWSER_CMD_RELOAD:
-			if (_startLocation != null) {
-				_browser.setUrl(_startLocation);
-			} else if (_startContent != null) {
-				_browser.setText(_startContent);
-			}
-			return true;
-
-		}
-		return false;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/CollapsableSection.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/CollapsableSection.java
deleted file mode 100644
index f787c22..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/CollapsableSection.java
+++ /dev/null
@@ -1,148 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.guiutils;
-
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.custom.ScrolledComposite;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.ui.forms.events.ExpansionAdapter;
-import org.eclipse.ui.forms.events.ExpansionEvent;
-import org.eclipse.ui.forms.widgets.ExpandableComposite;
-import org.eclipse.ui.forms.widgets.FormToolkit;
-import org.eclipse.ui.forms.widgets.Section;
-
-/**
- * Creates a class to be used to build a control for a collapseable area inside
- * a scrollable composite. This will take care of scrollbar resize.
- * 
- * Example use:
- * 
- * CollapsableSection cs = new CollapsableSection(toolkit, scomp, "General",
- * true) { public void setCollapsableContent(Composite composite) { // place
- * your content on this composite.... } }); cs.createControl(composite,
- * horizontalSpan);
- * 
- * @author mengbo
- * 
- */
-public abstract class CollapsableSection {
-	// internal fields needed for doing the section and computing the scrollbar
-	// on a collapse.
-	private FormToolkit _toolkit;
-
-	private Section _section;
-
-	private ScrolledComposite _scomp;
-
-	private String _title;
-
-	private int _expansionStyle;
-
-	/**
-	 * Creates a class to be used to build the control for a collapseable area.
-	 * 
-	 * @param toolkit 
-	 * 
-	 * @param scomp
-	 *            the scrollable composite used inside the container. This is
-	 *            used to force resizing of the bars on dinking the control.
-	 * @param title
-	 *            the string to place next to the collapsable icon.
-	 * @param bCollapsed
-	 *            should this area start collapsed?
-	 */
-	public CollapsableSection(FormToolkit toolkit, ScrolledComposite scomp,
-			String title, boolean bCollapsed) {
-		_toolkit = toolkit;
-		_scomp = scomp;
-		_title = title;
-		_expansionStyle = ExpandableComposite.TWISTIE
-				| ExpandableComposite.FOCUS_TITLE;
-		if (bCollapsed) {
-			_expansionStyle |= ExpandableComposite.COMPACT;
-		} else {
-			_expansionStyle |= ExpandableComposite.EXPANDED;
-		}
-	}
-
-	/**
-	 * Build the GUI parts of the Collapsable area into the given composite.
-	 * NOTE: you must set the layout on this composite before adding swt
-	 * widgets.
-	 * 
-	 * @param composite
-	 */
-	abstract public void setCollapsableContent(Composite composite);
-
-	/**
-	 * A convient way to build the widget into a control and place it on the
-	 * page. NOTE: this method will build the Section and call
-	 * setCollapsableContent with a composite to fill in the inner area.
-	 * 
-	 * @param parent
-	 * @param horizontalSpan
-	 *            how many columns should this control span.
-	 * @return Control that was added to the composite.
-	 */
-	public Control createControl(Composite parent, int horizontalSpan) {
-		_section = _toolkit.createSection(parent, _expansionStyle);
-		_section.clientVerticalSpacing = 5; // space between the dink and the
-		// controls in when opened.
-		// _section.marginHeight = 5; // indents the entire section.
-		// _section.marginWidth = 5; // indents the entire section.
-		_section.setText(_title);
-		_toolkit.createCompositeSeparator(_section);
-		_section.addExpansionListener(new ExpansionAdapter() {
-			public void expansionStateChanged(ExpansionEvent event) {
-				SWTUtils.computeScrollArea(_scomp, (Composite) _scomp
-						.getContent());
-			}
-		});
-
-		Composite content = new Composite(_section, SWT.NULL);
-		setCollapsableContent(content);
-
-		_section.setClient(content);
-		GridData gd = new GridData(GridData.FILL_HORIZONTAL);
-		gd.horizontalSpan = horizontalSpan;
-		_section.setLayoutData(gd);
-
-		return _section;
-	}
-
-	/**
-	 * Programmatically changes expanded state.
-	 * 
-	 * @param expanded
-	 *            the new expanded state
-	 */
-	public void setExpanded(boolean expanded) {
-		if (_section != null) {
-			_section.setExpanded(expanded);
-
-			// NOTE: internal calling of expanding doesn't fire
-			// the event to resize. We do it here.
-			SWTUtils.computeScrollArea(_scomp, (Composite) _scomp.getContent());
-		}
-	}
-
-	/**
-	 * Return the internal Section control for more advanced things.
-	 * 
-	 * @return Section
-	 */
-	public Section getSection() {
-		return _section;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/FavoriteSection.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/FavoriteSection.java
deleted file mode 100644
index be9882c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/FavoriteSection.java
+++ /dev/null
@@ -1,152 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.guiutils;
-
-import java.util.Properties;
-
-import org.eclipse.jst.jsf.common.ui.JSFUICommonPlugin;
-import org.eclipse.jst.jsf.common.ui.internal.utils.FavoriteConfigurations;
-import org.eclipse.swt.events.SelectionAdapter;
-import org.eclipse.swt.events.SelectionEvent;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.widgets.Button;
-import org.eclipse.swt.widgets.Combo;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Group;
-import org.eclipse.ui.plugin.AbstractUIPlugin;
-
-/**
- * Builds a favorites with the given name in the plugins resources. This build a
- * generic looking favorites section.
- * 
- * @author mengbo
- */
-public abstract class FavoriteSection {
-	private FavoriteConfigurations _favorites;
-
-	private Combo _favoriteCombo;
-
-	/**
-	 * @param plugin
-	 * @param favoriteName
-	 */
-	public FavoriteSection(AbstractUIPlugin plugin, String favoriteName) {
-		_favorites = new FavoriteConfigurations(plugin, favoriteName);
-	}
-
-	/**
-	 * @param parent
-	 * @param horizontalSpan
-	 * @param comboMinWidth
-	 * @return the combo
-	 */
-	public Combo createFavoriteGroup(Composite parent, int horizontalSpan,
-			int comboMinWidth) {
-		Group favGroup = SWTUtils.createGroup(parent, JSFUICommonPlugin
-				.getResourceString("favorites.group.label"), 4, horizontalSpan, //$NON-NLS-1$
-				GridData.BEGINNING | GridData.CENTER);
-
-		// Add favorite text field
-		SWTUtils.createLabel(favGroup, JSFUICommonPlugin
-				.getResourceString("favorites.label"), 1); //$NON-NLS-1$
-		_favoriteCombo = SWTUtils.createCombo(favGroup, _favorites
-				.getFavoritesList(), 1, comboMinWidth, true);
-		_favoriteCombo.setToolTipText(JSFUICommonPlugin
-				.getResourceString("favorites.tooltip")); //$NON-NLS-1$
-		_favoriteCombo.addSelectionListener(new SelectionAdapter() {
-			public void widgetSelected(SelectionEvent event) {
-				String favName = _favoriteCombo.getText().trim();
-				if (favName.length() > 0) {
-					Properties favProp = _favorites.getFavorite(_favoriteCombo
-							.getText().trim());
-					if (favProp != null) {
-						setFavorites(favProp);
-					}
-				}
-			}
-		});
-
-		// Add Save button
-		Button saveButton = SWTUtils.createPushButton(favGroup, JSFUICommonPlugin
-				.getResourceString("button.save")); //$NON-NLS-1$
-		saveButton.setToolTipText(JSFUICommonPlugin
-				.getResourceString("favorites.save.tooltip")); //$NON-NLS-1$
-		saveButton.addSelectionListener(new SelectionAdapter() {
-			public void widgetSelected(SelectionEvent event) {
-				String favName = _favoriteCombo.getText().trim();
-				if (favName.length() == 0) {
-					favName = JSFUICommonPlugin
-							.getResourceString("favorites.default"); //$NON-NLS-1$
-				}
-				Properties favProp = new Properties();
-				saveFavorites(favProp);
-
-				_favorites.addFavorite(favName, favProp);
-				_favorites.saveFavorites();
-
-				_favoriteCombo.removeAll();
-				String[] names = _favorites.getFavoritesList();
-
-				_favoriteCombo.setItems(names);
-				_favoriteCombo.setText(favName);
-			}
-		});
-
-		// Add Remove button
-		Button removeButton = SWTUtils.createPushButton(favGroup, JSFUICommonPlugin
-				.getResourceString("button.remove")); //$NON-NLS-1$
-		removeButton.setToolTipText(JSFUICommonPlugin
-				.getResourceString("favorites.remove.tooltip")); //$NON-NLS-1$
-		removeButton.addSelectionListener(new SelectionAdapter() {
-			public void widgetSelected(SelectionEvent event) {
-				String favName = _favoriteCombo.getText().trim();
-				if (favName.length() > 0) {
-					_favorites.removeFavorite(favName);
-					_favorites.saveFavorites();
-
-					removeFavorites();
-
-					_favoriteCombo.removeAll();
-					String[] names = _favorites.getFavoritesList();
-					_favoriteCombo.setItems(names);
-				}
-			}
-		});
-
-		return _favoriteCombo;
-	}
-
-	/**
-	 * This method will be called when a new favorite is set. This allows the
-	 * caller to set their values from the properties supplied.
-	 * 
-	 * @param prop
-	 */
-	public abstract void setFavorites(Properties prop);
-
-	/**
-	 * This method will be called when a new favorite is saved. This allows the
-	 * caller to save their values into the properties supplied.
-	 * 
-	 * @param prop
-	 */
-	public abstract void saveFavorites(Properties prop);
-
-	/**
-	 * This method will be called when the active favorite is removed. It allows
-	 * for clearing fields.
-	 */
-	public void removeFavorites() {
-		// do nothing.
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/ImageContainer.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/ImageContainer.java
deleted file mode 100644
index 8f697d1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/ImageContainer.java
+++ /dev/null
@@ -1,105 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.guiutils;
-
-
-import org.eclipse.draw2d.ColorConstants;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.ControlAdapter;
-import org.eclipse.swt.events.ControlEvent;
-import org.eclipse.swt.events.DisposeEvent;
-import org.eclipse.swt.events.DisposeListener;
-import org.eclipse.swt.events.PaintEvent;
-import org.eclipse.swt.events.PaintListener;
-import org.eclipse.swt.graphics.Image;
-import org.eclipse.swt.widgets.Composite;
-
-/**
- * A general purpose class for displying an image in a composite. There is no
- * eclipse tool for doing this other than CLabl which is bulkly.
- * 
- * This was original written by Karl Reti.
- * 
- * @author mengbo
- */
-public class ImageContainer extends Composite {
-	private Image _image = null;
-
-	private boolean _bCleanupImage;
-
-	/**
-	 * @param parent
-	 */
-	public ImageContainer(Composite parent) {
-		super(parent, SWT.NONE);// SWT.NO_BACKGROUND );//|
-		// SWT.NO_REDRAW_RESIZE);
-		setBackground(ColorConstants.white);
-		// paint the image
-		addPaintListener(new PaintListener() {
-			public void paintControl(PaintEvent e) {
-				if (_image != null) {
-					e.gc.drawImage(_image, 0, 0);
-				}
-			}
-
-		});
-
-		addControlListener(new ControlAdapter() {
-			public void controlResized(ControlEvent e) {
-				setSize(_image.getBounds().width, _image.getBounds().height);
-			}
-		});
-
-		// tidy up
-		addDisposeListener(new DisposeListener() {
-			public void widgetDisposed(DisposeEvent e) {
-				if (_bCleanupImage && _image != null && !_image.isDisposed()) {
-					_image.dispose();
-				}
-			}
-		});
-	}
-
-	/**
-	 * @return Returns the image.
-	 */
-	public Image getImage() {
-		return _image;
-	}
-
-	/**
-	 * @return should the image be disposed of on cleanup. Set false if the
-	 *         image is cached.
-	 */
-	public boolean isCleanupImage() {
-		return _bCleanupImage;
-	}
-
-	/**
-	 * @param image
-	 *            The image to set.
-	 */
-	public void setImage(Image image) {
-		setImage(image, false);
-	}
-
-	/**
-	 * @param image
-	 *            The image to set.
-	 * @param bCleanupImage 
-	 */
-	public void setImage(Image image, boolean bCleanupImage) {
-		_image = image;
-		_bCleanupImage = bCleanupImage;
-		setSize(image.getBounds().width, image.getBounds().height);
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/IntroductionSection.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/IntroductionSection.java
deleted file mode 100644
index a022c1b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/IntroductionSection.java
+++ /dev/null
@@ -1,351 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.jst.jsf.common.ui.internal.guiutils;
-
-import org.eclipse.core.runtime.IConfigurationElement;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.core.runtime.Platform;
-import org.eclipse.help.HelpSystem;
-import org.eclipse.help.IContext;
-import org.eclipse.help.IHelpResource;
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.resource.ImageDescriptor;
-import org.eclipse.jface.resource.ImageRegistry;
-import org.eclipse.jface.resource.JFaceResources;
-import org.eclipse.jst.jsf.common.ui.JSFUICommonPlugin;
-import org.eclipse.jst.jsf.common.ui.internal.logging.Logger;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.graphics.Image;
-import org.eclipse.swt.layout.RowLayout;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Label;
-import org.eclipse.ui.PlatformUI;
-import org.eclipse.ui.forms.IManagedForm;
-import org.eclipse.ui.forms.SectionPart;
-import org.eclipse.ui.forms.events.HyperlinkAdapter;
-import org.eclipse.ui.forms.events.HyperlinkEvent;
-import org.eclipse.ui.forms.widgets.ExpandableComposite;
-import org.eclipse.ui.forms.widgets.FormText;
-import org.eclipse.ui.forms.widgets.FormToolkit;
-import org.eclipse.ui.forms.widgets.Hyperlink;
-import org.eclipse.ui.forms.widgets.ImageHyperlink;
-import org.eclipse.ui.forms.widgets.Section;
-import org.eclipse.ui.forms.widgets.TableWrapData;
-import org.eclipse.ui.forms.widgets.TableWrapLayout;
-import org.eclipse.ui.plugin.AbstractUIPlugin;
-
-/**
- * Provides a standard looking introduction section for a intro page for the
- * editors. This was taken and is suppose to look like the standard Sybase
- * workspace service editors intro page.
- * 
- * this was original written by Collinsc
- * 
- * TODO: Should this be moved into the facesconfig ui plugin since it is only
- * really used there?
- * 
- * @author collinsc,jchoi
- */
-public class IntroductionSection extends SectionPart {
-
-	private static final String HELP_IMAGE_FILE = "help.gif"; //$NON-NLS-1$
-
-	private static Logger _log = JSFUICommonPlugin
-			.getLogger(IntroductionSection.class);
-
-	private String _editorId;
-
-	private FormToolkit _toolkit;
-
-	// private ImageHyperlink _helpImage;
-	private Composite _textClient;
-
-	private String _helpContextId;
-
-	private String _helpTooltip;
-
-	/**
-	 * Basic constructor - no help with this one.
-	 * 
-	 * @param editorId
-	 *            id of the editor this page is for.
-	 * @param managedForm
-	 * @param toolkit
-	 */
-	public IntroductionSection(String editorId, IManagedForm managedForm,
-			FormToolkit toolkit) {
-		this(editorId, managedForm, toolkit, null, null);
-	}
-
-	/**
-	 * Constructor with help option.
-	 * 
-	 * @param editorId
-	 *            id of the editor this page is for.
-	 * @param managedForm
-	 * @param toolkit
-	 * @param contextId 
-	 * @param helpTooltip
-	 */
-	public IntroductionSection(String editorId, IManagedForm managedForm,
-			FormToolkit toolkit, final String contextId, String helpTooltip) {
-		super(managedForm.getForm().getBody(), toolkit,
-				ExpandableComposite.TITLE_BAR | Section.DESCRIPTION);
-		super.initialize(managedForm);
-		this._editorId = editorId;
-		this._toolkit = toolkit;
-		this._helpContextId = contextId;
-		this._helpTooltip = helpTooltip;
-
-		this._textClient = this._toolkit.createComposite(getSection(), SWT.NONE);
-		this._textClient.setSize(32, 16);
-
-		RowLayout rowLayout = new RowLayout();
-		rowLayout.wrap = false;
-		rowLayout.pack = false;
-		rowLayout.justify = true;
-		rowLayout.type = SWT.HORIZONTAL;
-		rowLayout.marginLeft = 0;
-		rowLayout.marginTop = 0;
-		rowLayout.marginRight = 0;
-		rowLayout.marginBottom = 0;
-		rowLayout.spacing = 0;
-		this._textClient.setLayout(rowLayout);
-
-		this._toolkit.adapt(this._textClient, true, true);
-		getSection().setTextClient(this._textClient);
-
-		if (this._helpContextId != null) {
-			// setup the help image.
-			ImageHyperlink helpImage = new ImageHyperlink(this._textClient,
-					SWT.NONE);
-			this._toolkit.adapt(helpImage, true, true);
-			helpImage.setImage(JSFUICommonPlugin.getDefault().getImage(HELP_IMAGE_FILE));
-			if (this._helpTooltip != null) {
-				helpImage.setToolTipText(this._helpTooltip);
-			}
-			helpImage.setBackground(getSection()
-					.getTitleBarGradientBackground());
-			helpImage.addHyperlinkListener(new HyperlinkAdapter() {
-				public void linkActivated(HyperlinkEvent e) {
-					IContext context = HelpSystem.getContext(_helpContextId);
-					if (context != null) {
-						IHelpResource[] topics = context.getRelatedTopics();
-						if (topics != null && topics.length == 1) {
-                            PlatformUI.getWorkbench().getHelpSystem().displayHelpResource(topics[0]
-									.getHref());
-						} else {
-                            PlatformUI.getWorkbench().getHelpSystem().displayHelp(_helpContextId);
-						}
-					}
-				}
-			});
-		}
-
-		Composite client = this._toolkit.createComposite(getSection());
-		createClient(client, this._toolkit);
-		getSection().setClient(client);
-	}
-
-	private Composite createClient(Composite container, FormToolkit factory) {
-		TableWrapLayout layout = new TableWrapLayout();
-		layout.numColumns = 2;
-		layout.makeColumnsEqualWidth = false;
-		layout.horizontalSpacing = 20;
-		layout.verticalSpacing = 20;
-		container.setLayout(layout);
-
-		IConfigurationElement element = getExtensions();
-
-		if (element != null) {
-			setPageDetails(element);
-
-			IConfigurationElement[] children = element.getChildren();
-			for (int ii = 0; ii < children.length; ii++) {
-				processItems(container, factory, children[ii]);
-			}
-		} else {
-			setText(Messages.IntroductionSection_noIntroTitle);
-
-			setDescription(Messages.IntroductionSection_noIntroDescription);
-		}
-
-		factory.paintBordersFor(container);
-        PlatformUI.getWorkbench().getHelpSystem().setHelp(container, _helpContextId);
-		return container;
-	}
-
-	/**
-	 * set the page details from the extensionpoint
-	 * 
-	 * @param element
-	 */
-	private void setPageDetails(IConfigurationElement element) {
-		setText(element.getAttribute("name")); //$NON-NLS-1$
-		setDescription(element.getAttribute("description")); //$NON-NLS-1$
-	}
-
-	/**
-	 * add the extension elements to the page
-	 * 
-	 * @param parent
-	 * @param toolkit_
-	 * @param element
-	 */
-	private void processItems(Composite parent, FormToolkit toolkit_,
-			IConfigurationElement element) {
-		String hyperlink = element.getAttribute("hyperlink"); //$NON-NLS-1$
-		String iconPath = element.getAttribute("icon"); //$NON-NLS-1$
-		String text = element.getAttribute("text"); //$NON-NLS-1$
-		String heading = element.getAttribute("heading"); //$NON-NLS-1$
-		String action = element.getAttribute("hyperlinkaction"); //$NON-NLS-1$
-		//String actionparameters = element.getAttribute("actionparameters"); //$NON-NLS-1$
-
-		if (iconPath != null && iconPath.length() > 0) {
-			// add an icon to the page
-			String iconName;
-			if (iconPath.indexOf(IPath.SEPARATOR) != -1) {
-				iconName = new Path(iconPath).lastSegment();
-			} else {
-				iconName = iconPath;
-			}
-
-			ImageDescriptor imageDescriptor = AbstractUIPlugin
-					.imageDescriptorFromPlugin(
-							element.getDeclaringExtension()
-									.getContributor().getName(), iconPath);
-			
-			if (imageDescriptor != null)
-			{
-				ImageRegistry imageRegistry =
-					JSFUICommonPlugin.getDefault().getImageRegistry();
-				
-				
-				Image image = imageRegistry.get(iconName);
-				
-				if (image == null)
-				{
-					image = imageDescriptor.createImage();
-					
-					if (image != null)
-					{
-						imageRegistry.put(iconName, image);
-					}
-					else
-					{
-						image = ImageDescriptor.getMissingImageDescriptor().createImage();
-					}
-				}
-				
-				if (image != null)
-				{
-					ImageContainer img = new ImageContainer(parent);
-					img.setImage(image);
-					TableWrapData td = new TableWrapData();
-					td.rowspan = 2;
-					img.setLayoutData(td);
-				}
-				else
-				{
-					JSFUICommonPlugin.getLogger(this.getClass()).error(new Throwable("Image not created for "+element)); //$NON-NLS-1$
-				}
-			}
-			else
-			{
-				JSFUICommonPlugin.getLogger(this.getClass()).error(new Throwable("Image Descriptor not found for "+element)); //$NON-NLS-1$
-			}
-		}
-
-		if (heading != null && heading.length() > 0) {
-			// add a header
-			Label lbl = toolkit_.createLabel(parent, heading);
-			lbl.setFont(JFaceResources.getHeaderFont());
-		}
-
-		if (hyperlink != null && hyperlink.length() > 0) {
-			Hyperlink hypr = toolkit_.createHyperlink(parent, hyperlink,
-					SWT.NONE);
-			if (action != null && action.length() > 0) {
-				try {
-					final IAction thisAction = (IAction) element
-							.createExecutableExtension("hyperlinkaction"); //$NON-NLS-1$
-					hypr.addHyperlinkListener(new HyperlinkAdapter() {
-						public void linkActivated(HyperlinkEvent e) {
-							thisAction.run();
-						}
-					});
-				} catch (Exception ee) {
-					// log.IntroductionSection.action.error=Failed to launch the
-					// link {0}.
-					_log.error("log.IntroductionSection.action.error", //$NON-NLS-1$
-							hyperlink, ee);
-					JSFUICommonPlugin.getAlerts().detailError(hyperlink,
-							"log.IntroductionSection.action.error", hyperlink, //$NON-NLS-1$
-							ee);
-				}
-			}
-		}
-
-		if (text != null && text.length() > 0) {
-			FormText form = toolkit_.createFormText(parent, false);
-			form.setText(text, false, false);
-		}
-	}
-
-	/**
-	 * Get the extension elements for the Introduction pages
-	 */
-	private IConfigurationElement getExtensions() {
-		// find all service editor page extensions
-		IConfigurationElement element = null;
-
-		// find all service editor parameter dialog extensions
-		IConfigurationElement[] elements = Platform
-				.getExtensionRegistry()
-				.getConfigurationElementsFor(
-						"org.eclipse.jst.jsf.common.ui.introductionPage"); //$NON-NLS-1$
-		if (elements.length > 0) {
-			for (int ii = 0; ii < elements.length; ii++) {
-				// get extensions for this dialog
-				// String extPluginId =
-				// elements[ii].getDeclaringExtension().getNamespace();
-				String editorId1 = elements[ii].getDeclaringExtension()
-						.getSimpleIdentifier();
-
-				// see if we have any contributuins of dialogs
-				if (this._editorId.equals(editorId1)) {
-					element = elements[ii];
-					break;
-				}
-			}
-		}
-		return element;
-	}
-
-	private void setText(String text) {
-		getSection().setText(text);
-	}
-
-	private void setDescription(String text) {
-		getSection().setDescription(text);
-	}
-
-	/**
-	 * Set this section's layout data
-	 * @param layoutData
-	 */
-	public void setLayoutData(Object layoutData) {
-		getSection().setLayoutData(layoutData);
-	}
-}
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/Messages.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/Messages.java
deleted file mode 100644
index b877236..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/Messages.java
+++ /dev/null
@@ -1,35 +0,0 @@
-package org.eclipse.jst.jsf.common.ui.internal.guiutils;
-
-import org.eclipse.osgi.util.NLS;
-
-/**
- * String resource handler.
- * 
- * @author Debajit Adhikary - Oracle
- */
-
-public class Messages extends NLS {
-
-	private static final String BUNDLE_NAME = "org.eclipse.jst.jsf.common.ui.internal.guiutils.messages"; //$NON-NLS-1$
-	
-	/**
-	 * See messages.properties.
-	 */
-	public static String IntroductionSection_noIntroDescription;
-	
-	/**
-	 * See messages.properties.
-	 */
-	public static String IntroductionSection_noIntroTitle;
-	
-	/**
-	 * See messages.properties.
-	 */
-	public static String BrowserWindow_loading;
-
-	
-	static {
-		// initialize resource bundle
-		NLS.initializeMessages(BUNDLE_NAME, Messages.class);
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/OverviewSection.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/OverviewSection.java
deleted file mode 100644
index 4654c40..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/OverviewSection.java
+++ /dev/null
@@ -1,287 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.guiutils;
-
-import org.eclipse.core.runtime.IConfigurationElement;
-import org.eclipse.core.runtime.Platform;
-import org.eclipse.help.HelpSystem;
-import org.eclipse.help.IContext;
-import org.eclipse.help.IHelpResource;
-import org.eclipse.jface.action.IAction;
-import org.eclipse.jst.jsf.common.ui.JSFUICommonPlugin;
-import org.eclipse.jst.jsf.common.ui.internal.logging.Logger;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.layout.RowLayout;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.ui.PlatformUI;
-import org.eclipse.ui.forms.IManagedForm;
-import org.eclipse.ui.forms.SectionPart;
-import org.eclipse.ui.forms.editor.FormEditor;
-import org.eclipse.ui.forms.events.HyperlinkAdapter;
-import org.eclipse.ui.forms.events.HyperlinkEvent;
-import org.eclipse.ui.forms.widgets.ExpandableComposite;
-import org.eclipse.ui.forms.widgets.FormText;
-import org.eclipse.ui.forms.widgets.FormToolkit;
-import org.eclipse.ui.forms.widgets.Hyperlink;
-import org.eclipse.ui.forms.widgets.ImageHyperlink;
-import org.eclipse.ui.forms.widgets.Section;
-
-
-/**
- * @author jchoi
- * @version
- */
-public class OverviewSection extends SectionPart {
-
-	private static final String HELP_IMAGE_FILE = "help.gif"; //$NON-NLS-1$
-
-	private static Logger log = JSFUICommonPlugin.getLogger(OverviewSection.class);
-
-	private String editorId;
-
-	private FormToolkit toolkit;
-
-	private ImageHyperlink helpImage;
-
-	private Composite textClient;
-
-	private String helpContextId;
-
-	private String helpTooltip;
-
-	/**
-	 * @param editorId 
-	 * @param managedForm 
-	 * @param toolkit
-	 */
-	public OverviewSection(String editorId, IManagedForm managedForm,
-			FormToolkit toolkit) {
-		this(editorId, managedForm, toolkit, null, null);
-
-	}
-
-	/**
-	 * Constructor with help option.
-	 * 
-	 * @param editorId
-	 *            id of the editor this page is for.
-	 * @param managedForm
-	 * @param toolkit
-	 * @param helpContextId
-	 * @param helpTooltip
-	 */
-	public OverviewSection(String editorId, IManagedForm managedForm,
-			FormToolkit toolkit, String helpContextId, String helpTooltip) {
-		super(managedForm.getForm().getBody(), toolkit,
-				ExpandableComposite.TITLE_BAR | Section.DESCRIPTION);
-		super.initialize(managedForm);
-		this.editorId = editorId;
-		this.toolkit = toolkit;
-		this.helpContextId = helpContextId;
-		this.helpTooltip = helpTooltip;
-
-		this.textClient = this.toolkit.createComposite(getSection(), SWT.NONE);
-		this.textClient.setSize(32, 16);
-
-		init();
-
-		Composite client = this.toolkit.createComposite(getSection());
-		//createClient(client, this.toolkit);
-		getSection().setClient(client);
-	}
-
-	/**
-	 * @param editor 
-	 * @param managedForm 
-	 * @param toolkit
-	 * @param style
-	 */
-	public OverviewSection(FormEditor editor, IManagedForm managedForm,
-			FormToolkit toolkit, int style) {
-		super(managedForm.getForm().getBody(), toolkit,
-				ExpandableComposite.TITLE_BAR | style);
-		super.initialize(managedForm);
-		this.toolkit = toolkit;
-
-		this.textClient = this.toolkit.createComposite(getSection(), SWT.NONE);
-		this.textClient.setSize(32, 16);
-
-		init();
-	}
-
-	/**
-	 * @param editor
-	 * @param managedForm
-	 * @param toolkit
-	 * @param style
-	 * @param helpContextId
-	 * @param helpTooltip
-	 */
-	public OverviewSection(FormEditor editor, IManagedForm managedForm,
-			FormToolkit toolkit, int style, String helpContextId,
-			String helpTooltip) {
-		super(managedForm.getForm().getBody(), toolkit,
-				ExpandableComposite.TITLE_BAR | style);
-		super.initialize(managedForm);
-		this.toolkit = toolkit;
-
-		this.textClient = toolkit.createComposite(getSection(), SWT.NONE);
-		this.textClient.setSize(32, 16);
-		this.helpContextId = helpContextId;
-		this.helpTooltip = helpTooltip;
-		init();
-	}
-
-	/**
-	 * 
-	 */
-	public void initialize() {
-		Composite client = toolkit.createComposite(getSection());
-		//createClient(client, toolkit);
-		getSection().setClient(client);
-	}
-
-	private void init() {
-		RowLayout rowLayout = new RowLayout();
-		rowLayout.wrap = false;
-		rowLayout.pack = false;
-		rowLayout.justify = true;
-		rowLayout.type = SWT.HORIZONTAL;
-		rowLayout.marginLeft = 0;
-		rowLayout.marginTop = 0;
-		rowLayout.marginRight = 0;
-		rowLayout.marginBottom = 0;
-		rowLayout.spacing = 0;
-		textClient.setLayout(rowLayout);
-
-		helpImage = new ImageHyperlink(textClient, SWT.NONE);
-		toolkit.adapt(helpImage, true, true);
-		toolkit.adapt(textClient, true, true);
-		helpImage.setImage(JSFUICommonPlugin.getDefault().getImage(HELP_IMAGE_FILE)); 
-		getSection().setTextClient(textClient);
-		if (helpTooltip != null) {
-			helpImage.setToolTipText(helpTooltip);
-		}
-		helpImage.setBackground(getSection().getTitleBarGradientBackground());
-		helpImage.addHyperlinkListener(new HyperlinkAdapter() {
-			public void linkActivated(HyperlinkEvent e) {
-				IContext context = HelpSystem.getContext(helpContextId);
-				if (context != null) {
-					IHelpResource[] topics = context.getRelatedTopics();
-					if (topics != null && topics.length == 1) {
-                        PlatformUI.getWorkbench().getHelpSystem().displayHelpResource(topics[0].getHref());
-					} else {
-                        PlatformUI.getWorkbench().getHelpSystem().displayHelp(helpContextId);
-					}
-				}
-			}
-		});
-
-		/*
-		 * Composite client = _toolkit.createComposite(getSection());
-		 * createClient(client, _toolkit); getSection().setClient(client);
-		 */
-	}
-
-	/**
-	 * set the page details from the extensionpoint
-	 * 
-	 * @param element
-	 */
-	protected void setPageDetails(IConfigurationElement element) {
-		setText(element.getAttribute("name")); //$NON-NLS-1$
-		setDescription(element.getAttribute("description")); //$NON-NLS-1$
-	}
-
-	/**
-	 * add the extension elements to the page
-	 * 
-	 * @param parent
-	 * @param toolkit_
-	 * @param element
-	 */
-	public void processItems(Composite parent, FormToolkit toolkit_,
-			IConfigurationElement element) {
-		String hyperlink = element.getAttribute("hyperlink"); //$NON-NLS-1$      
-		String text = element.getAttribute("text"); //$NON-NLS-1$
-		String action = element.getAttribute("hyperlinkaction"); //$NON-NLS-1$
-		//String actionparameters = element.getAttribute("actionparameters"); //$NON-NLS-1$
-
-		if (hyperlink != null && hyperlink.length() > 0) {
-			Hyperlink hypr = toolkit_.createHyperlink(parent, hyperlink,
-					SWT.NONE);
-			if (action != null && action.length() > 0) {
-				try {
-					final IAction thisAction = (IAction) element
-							.createExecutableExtension("hyperlinkaction"); //$NON-NLS-1$
-					hypr.addHyperlinkListener(new HyperlinkAdapter() {
-						public void linkActivated(HyperlinkEvent e) {
-							thisAction.run();
-						}
-					});
-				} catch (Exception ee) {
-					// log.IntroductionSection.action.error=Failed to launch the
-					// link {0}.
-					log
-							.error("log.OverviewSection.action.error", //$NON-NLS-1$
-									hyperlink, ee);
-					JSFUICommonPlugin.getAlerts().detailError(hyperlink,
-							"log.OverviewSection.action.error", hyperlink, ee); //$NON-NLS-1$
-				}
-			}
-		}
-
-		if (text != null && text.length() > 0) {
-			FormText form = toolkit_.createFormText(parent, false);
-			form.setText(text, false, false);
-		}
-	}
-
-	/**
-	 * Get the extension elements for the Introduction pages
-	 * @param extensionPoint 
-	 * @return the configuration element
-	 */
-	public IConfigurationElement getExtensions(String extensionPoint) {
-		// find all service editor page extensions
-		IConfigurationElement element = null;
-
-		// find all service editor parameter dialog extensions
-		IConfigurationElement[] elements = Platform.getExtensionRegistry()
-				.getConfigurationElementsFor(extensionPoint);
-		if (elements.length > 0) {
-			for (int ii = 0; ii < elements.length; ii++) {
-				// get extensions for this dialog
-				// String extPluginId =
-				// elements[ii].getDeclaringExtension().getNamespace();
-				String anEditorId = elements[ii].getDeclaringExtension()
-						.getSimpleIdentifier();
-
-				// see if we have any contributuins of dialogs
-				if (this.editorId.equals(anEditorId)) {
-					element = elements[ii];
-					break;
-				}
-			}
-		}
-		return element;
-	}
-
-	private void setText(String text) {
-		getSection().setText(text);
-	}
-
-	private void setDescription(String text) {
-		getSection().setDescription(text);
-
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/SWTUtils.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/SWTUtils.java
deleted file mode 100644
index 862b26b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/SWTUtils.java
+++ /dev/null
@@ -1,1032 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.guiutils;
-
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.custom.ScrolledComposite;
-import org.eclipse.swt.events.ControlEvent;
-import org.eclipse.swt.events.ControlListener;
-import org.eclipse.swt.graphics.Color;
-import org.eclipse.swt.graphics.Image;
-import org.eclipse.swt.graphics.Point;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.layout.GridLayout;
-import org.eclipse.swt.widgets.Button;
-import org.eclipse.swt.widgets.Combo;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Group;
-import org.eclipse.swt.widgets.Label;
-import org.eclipse.swt.widgets.List;
-import org.eclipse.swt.widgets.Table;
-import org.eclipse.swt.widgets.TableColumn;
-import org.eclipse.swt.widgets.Text;
-
-/**
- * This utility class provides convenience methods in creating controls on
- * preference pages.
- * 
- * @author mengbo
- */
-public class SWTUtils {
-	// Defaults of controls
-	private static final int DEFAULT_BUTTON_WIDTH = 70;
-
-	private static final int DEFAULT_COMBO_WIDTH = 100;
-
-	private static final int DEFAULT_TEXTBOX_WIDTH = 100;
-
-	private static final int DEFAULT_RADIO_FILL = GridData.HORIZONTAL_ALIGN_BEGINNING
-			| GridData.VERTICAL_ALIGN_CENTER;
-
-	/**
-	 * Creates a new checkbox and sets the default layout data.
-	 * 
-	 * @param parent
-	 *            the composite in which to create the checkbox
-	 * @return the new checkbox
-	 */
-	public static Button createCheckBox(Composite parent) {
-		return createCheckBox(parent, null, 1, 0);
-	}
-
-	/**
-	 * Creates a new checkbox and sets the default layout data.
-	 * 
-	 * @param parent
-	 *            the composite in which to create the checkbox
-	 * @param label
-	 *            the string to set into the checkbox
-	 * @param numColumns
-	 *            the number of columns the new checkbox is to occupy
-	 * @return the new checkbox
-	 */
-	public static Button createCheckBox(Composite parent, String label,
-			int numColumns) {
-		return createCheckBox(parent, label, numColumns, 0);
-	}
-
-	/**
-	 * Creates a new checkbox and sets the default layout data.
-	 * 
-	 * @param parent
-	 *            the composite in which to create the checkbox
-	 * @param label
-	 *            the string to set into the checkbox
-	 * @param numColumns
-	 *            the number of columns the new checkbox is to occupy
-	 * @param indent
-	 *            the number of pixels to indent from the left
-	 * @return the new checkbox
-	 */
-	public static Button createCheckBox(Composite parent, String label,
-			int numColumns, int indent) {
-		Button button = new Button(parent, SWT.CHECK | SWT.LEFT);
-		if (label == null) {
-			button.setAlignment(SWT.CENTER);
-		}
-		GridData data = new GridData(GridData.FILL);
-		data.horizontalSpan = numColumns;
-		data.horizontalIndent = indent;
-		button.setLayoutData(data);
-		if (label != null) {
-			button.setText(label);
-		}
-		return button;
-	}
-
-	/**
-	 * Creates a combo box and sets the default layout data.
-	 * 
-	 * @param parent
-	 *            the composite in which to create the combo
-	 * @param items
-	 *            the items in the combo
-	 * @param numColumns
-	 *            the number of columns the new combo is to occupy
-	 * @return the new combo box
-	 */
-	public static Combo createCombo(Composite parent, String[] items,
-			int numColumns) {
-		return createCombo(parent, items, numColumns, DEFAULT_COMBO_WIDTH);
-	}
-
-	/**
-	 * Creates a combo box and sets the default layout data.
-	 * 
-	 * @param parent
-	 *            the composite in which to create the combo
-	 * @param tokenString
-	 *            a tokenized string that will be split into the fields.
-	 * @param numColumns
-	 *            the number of columns the new combo is to occupy
-	 * @return the new combo box
-	 */
-	public static Combo createCombo(Composite parent, String tokenString,
-			int numColumns) {
-		return createCombo(parent, getTokenNames(tokenString), numColumns,
-				DEFAULT_COMBO_WIDTH);
-	}
-
-	/**
-	 * Creates a combo box and sets the default layout data.
-	 * 
-	 * @param parent
-	 *            the composite in which to create the combo
-	 * @param tokenString
-	 *            a tokenized string that will be split into the fields.
-	 * @param numColumns
-	 *            the number of columns the new combo is to occupy
-	 * @param minWidth
-	 *            minimum width of combo box in pixels
-	 * @return the new combo box
-	 */
-	public static Combo createCombo(Composite parent, String tokenString,
-			int numColumns, int minWidth) {
-		return createCombo(parent, getTokenNames(tokenString), numColumns,
-				minWidth);
-	}
-
-	/**
-	 * Creates a combo box and sets the default layout data.
-	 * 
-	 * @param parent
-	 *            the composite in which to create the combo
-	 * @param items
-	 *            the items in the combo
-	 * @param numColumns
-	 *            the number of columns the new combo is to occupy
-	 * @param minWidth
-	 *            minimum width of combo box in pixels
-	 * @return the new combo box
-	 */
-	public static Combo createCombo(Composite parent, String[] items,
-			int numColumns, int minWidth) {
-		return createCombo(parent, items, numColumns, minWidth, false);
-	}
-
-	/**
-	 * Creates a combo box and sets the default layout data.
-	 * 
-	 * @param parent
-	 *            the composite in which to create the combo
-	 * @param tokenString 
-	 * @param numColumns
-	 *            the number of columns the new combo is to occupy
-	 * @param minWidth
-	 *            minimum width of combo box in pixels
-	 * @param editable
-	 *            whether the items in the combo is editable
-	 * @return the new combo box
-	 */
-	public static Combo createCombo(Composite parent, String tokenString,
-			int numColumns, int minWidth, boolean editable) {
-		return createCombo(parent, getTokenNames(tokenString), numColumns,
-				minWidth, editable);
-	}
-
-	/**
-	 * Creates a combo box and sets the default layout data.
-	 * 
-	 * @param parent
-	 *            the composite in which to create the combo
-	 * @param items
-	 *            the items in the combo
-	 * @param numColumns
-	 *            the number of columns the new combo is to occupy
-	 * @param minWidth
-	 *            minimum width of combo box in pixels
-	 * @param editable
-	 *            whether the items in the combo is editable
-	 * @return the new combo box
-	 */
-	public static Combo createCombo(Composite parent, String[] items,
-			int numColumns, int minWidth, boolean editable) {
-		Combo combo;
-		GridData data;
-		if (editable) {
-			combo = new Combo(parent, SWT.DROP_DOWN);
-			data = new GridData(GridData.FILL_HORIZONTAL);
-		} else {
-			combo = new Combo(parent, SWT.DROP_DOWN | SWT.READ_ONLY);
-			data = new GridData(GridData.FILL);
-		}
-		data.horizontalSpan = numColumns;
-		data.widthHint = minWidth;
-		combo.setLayoutData(data);
-		combo.setItems(items);
-		return combo;
-	}
-
-	/**
-	 * Creates composite control and sets the default layout data.
-	 * 
-	 * @param parent
-	 *            the parent of the new composite
-	 * @param numColumns
-	 *            the number of columns for the new composite
-	 * @return the newly-created coposite
-	 */
-	public static Composite createComposite(Composite parent, int numColumns) {
-		return createComposite(parent, numColumns, -1, -1,
-				GridData.FILL_HORIZONTAL, -1, -1, -1);
-	}
-
-	/**
-	 * Creates composite control and sets the default layout data.
-	 * 
-	 * @param parent
-	 *            the parent of the new composite
-	 * @param numColumns
-	 *            the number of columns for the new composite
-	 * @param verticalSpacing
-	 *            the spacing between rows.
-	 * @param horizontalSpan
-	 *            the span for this new composite over the original composite.
-	 * @return the newly-created coposite
-	 */
-	public static Composite createComposite(Composite parent, int numColumns,
-			int verticalSpacing, int horizontalSpan) {
-		return createComposite(parent, numColumns, verticalSpacing,
-				horizontalSpan, GridData.FILL_HORIZONTAL, -1, -1, -1);
-	}
-
-	/**
-	 * Creates composite control and sets the default layout data.
-	 * 
-	 * @param parent
-	 *            the parent of the new composite
-	 * @param numColumns
-	 *            the number of columns for the new composite
-	 * @param verticalSpacing
-	 *            the spacing between rows.
-	 * @param horizontalSpan
-	 *            the span for this new composite over the original composite.
-	 * @param gridDataFill
-	 *            the fill to use for this composite.
-	 * @return the newly-created coposite
-	 */
-	public static Composite createComposite(Composite parent, int numColumns,
-			int verticalSpacing, int horizontalSpan, int gridDataFill) {
-		return createComposite(parent, numColumns, verticalSpacing,
-				horizontalSpan, gridDataFill, -1, -1, -1);
-	}
-
-	/**
-	 * Creates composite control and sets the default layout data.
-	 * 
-	 * @param parent
-	 *            the parent of the new composite
-	 * @param numColumns
-	 *            the number of columns for the new composite
-	 * @param verticalSpacing
-	 *            the spacing between rows.
-	 * @param horizontalSpan
-	 *            the span for this new composite over the original composite.
-	 * @param gridDataFill
-	 *            the fill to use for this composite.
-	 * @param horizontalSpacing
-	 *            the spacing between objects.
-	 * @param marginWidth
-	 *            the spacing at start and end of composite.
-	 * @param marginHeight
-	 *            the spacing above and below composite.
-	 * @return the newly-created coposite
-	 */
-	public static Composite createComposite(Composite parent, int numColumns,
-			int verticalSpacing, int horizontalSpan, int gridDataFill,
-			int horizontalSpacing, int marginWidth, int marginHeight) {
-		Composite composite = new Composite(parent, SWT.NULL);
-		GridLayout layout = new GridLayout();
-		layout.numColumns = numColumns;
-		if (verticalSpacing >= 0) {
-			layout.verticalSpacing = verticalSpacing;
-		}
-		if (horizontalSpacing >= 0) {
-			layout.horizontalSpacing = horizontalSpacing;
-		}
-		if (marginWidth >= 0) {
-			layout.marginWidth = marginWidth;
-		}
-		if (marginHeight >= 0) {
-			layout.marginHeight = marginHeight;
-		}
-		composite.setLayout(layout);
-		GridData gd = new GridData(gridDataFill);
-		if (horizontalSpan > 0) {
-			gd.horizontalSpan = horizontalSpan;
-		}
-		composite.setLayoutData(gd);
-
-		return composite;
-	}
-
-	/**
-	 * Utility method that creates a group and sets the default layout data.
-	 * 
-	 * @param parent
-	 *            the parent for the new group
-	 * @param title
-	 *            the label for the new group
-	 * @param numColumns
-	 *            the number of columns for the new group
-	 * @return the newly created group
-	 */
-	public static Group createGroup(Composite parent, String title,
-			int numColumns) {
-		return createGroup(parent, title, numColumns, -1,
-				GridData.FILL_HORIZONTAL);
-	}
-
-	/**
-	 * Utility method that creates a group and sets the default layout data.
-	 * 
-	 * @param parent
-	 *            the parent for the new group
-	 * @param title
-	 *            the label for the new group
-	 * @param numColumns
-	 *            the number of columns for the new group
-	 * @param horizontalSpan
-	 *            the number of columns this group should span on the parent
-	 *            composite.
-	 * @param gridDataFill
-	 *            the fill style of the new group -- set to for filling just
-	 *            around the object: GridData.BEGINNING | GridData.CENTER
-	 * @return the newly created group
-	 */
-	public static Group createGroup(Composite parent, String title,
-			int numColumns, int horizontalSpan, int gridDataFill) {
-		Group group = new Group(parent, SWT.SHADOW_ETCHED_IN);
-		GridLayout layout = new GridLayout();
-		layout.numColumns = numColumns;
-		group.setLayout(layout);
-		GridData data = new GridData(gridDataFill);
-
-		if (horizontalSpan > 0) {
-			data.horizontalSpan = horizontalSpan;
-		}
-		group.setLayoutData(data);
-		group.setText(title);
-		return group;
-	}
-
-	/**
-	 * Utility method that creates a label instance and sets the default layout
-	 * data.
-	 * 
-	 * @param parent
-	 *            the parent for the new label
-	 * @param text
-	 *            the text for the new label
-	 * @param numColumns
-	 *            the number of columns for the new composite
-	 * @return the new label
-	 */
-	public static Label createLabel(Composite parent, String text,
-			int numColumns) {
-		return createLabel(parent, text, numColumns, 0);
-	}
-
-	/**
-	 * Utility method that creates a label instance and sets the default layout
-	 * data.
-	 * 
-	 * @param parent
-	 *            the parent for the new label
-	 * @param text
-	 *            the text for the new label
-	 * @param numColumns
-	 *            the number of columns for the new composite
-	 * @param indent
-	 *            number of pixels to indent from the left
-	 * @return the new label
-	 */
-	public static Label createLabel(Composite parent, String text,
-			int numColumns, int indent) {
-		Label label = new Label(parent, SWT.LEFT);
-		GridData data = new GridData();
-		data.horizontalSpan = numColumns;
-		data.horizontalAlignment = GridData.FILL;
-		data.horizontalIndent = indent;
-		label.setLayoutData(data);
-		label.setText(text);
-		return label;
-	}
-
-	/**
-	 * Create a image label for sticking in a composite. The backgroud color is
-	 * optional. Because images can have "transparent" natures, you might want
-	 * to say the background is something other than the defaults composites
-	 * background.
-	 * 
-	 * NOTE: the caller is responsible for cleanup of the image and color
-	 * objects.
-	 * 
-	 * @param parent
-	 *            the parent for the new label
-	 * @param theImage
-	 *            the image for the new label
-	 * @param numColumns
-	 *            the number of columns for the new composite
-	 * @param background
-	 *            pass null to use the composites background.
-	 * @return the new label
-	 */
-	public static Label createLabelImage(Composite parent, Image theImage,
-			int numColumns, Color background) {
-		Label label = new Label(parent, SWT.LEFT);
-		GridData data = new GridData();
-		data.horizontalSpan = numColumns;
-		data.horizontalAlignment = GridData.FILL;
-		label.setLayoutData(data);
-		if (background != null) {
-			label.setBackground(background);
-		}
-		label.setImage(theImage);
-		return label;
-	}
-
-	/**
-	 * Utility method that creates a push button instance and sets the default
-	 * layout data.
-	 * 
-	 * @param parent
-	 *            the parent for the new button
-	 * @param label
-	 *            the label for the new button
-	 * @return the newly-created button
-	 */
-	public static Button createPushButton(Composite parent, String label) {
-		return createPushButton(parent, label, DEFAULT_BUTTON_WIDTH);
-	}
-
-	/**
-	 * Utility method that creates a push button instance and sets the default
-	 * layout data.
-	 * 
-	 * @param parent
-	 *            the parent for the new button
-	 * @param label
-	 *            the label for the new button
-	 * @param widthHint
-	 *            use this width for the button.
-	 * @return the newly-created button
-	 */
-	public static Button createPushButton(Composite parent, String label,
-			int widthHint) {
-		Button button = new Button(parent, SWT.PUSH);
-		GridData data = new GridData();
-		data.horizontalAlignment = GridData.FILL_HORIZONTAL;
-		data.widthHint = widthHint;
-		button.setLayoutData(data);
-		button.setText(label);
-		return button;
-	}
-
-	/**
-	 * Utility method that creates a push button instance and sets the default
-	 * layout data.
-	 * 
-	 * @param parent
-	 *            the parent for the new button
-	 * @param theImage
-	 *            the label for the new button
-	 * @param widthHint
-	 *            use this width for the button.
-	 * @return the newly-created button
-	 */
-	public static Button createPushButton(Composite parent, Image theImage,
-			int widthHint) {
-		Button button = new Button(parent, SWT.PUSH);
-		GridData data = new GridData();
-		data.horizontalAlignment = GridData.FILL_HORIZONTAL;
-		data.widthHint = widthHint;
-		button.setLayoutData(data);
-		button.setImage(theImage);
-		button.setAlignment(SWT.CENTER);
-		return button;
-	}
-
-	/**
-	 * Utility method that creates a radio button instance and sets the default
-	 * layout data.
-	 * 
-	 * @param parent
-	 *            the parent for the new button
-	 * @param label
-	 *            the label for the new button
-	 * @return the newly-created button
-	 */
-	public static Button createRadioButton(Composite parent, String label) {
-		return createRadioButton(parent, label, DEFAULT_RADIO_FILL);
-	}
-
-	/**
-	 * Utility method that creates a radio button instance and sets the default
-	 * layout data.
-	 * 
-	 * @param parent
-	 *            the parent for the new button
-	 * @param label
-	 *            the label for the new button
-	 * @param gridDataFill 
-	 * @return the newly-created button
-	 */
-	public static Button createRadioButton(Composite parent, String label,
-			int gridDataFill) {
-		return createRadioButton(parent, label, gridDataFill, 1);
-	}
-
-	/**
-	 * Utility method that creates a radio button instance and sets the default
-	 * layout data.
-	 * 
-	 * @param parent
-	 *            the parent for the new button
-	 * @param label
-	 *            the label for the new button
-	 * @param gridDataFill 
-	 * @param horizontalSpan
-	 *            number of columns occupied by button
-	 * @return the newly-created button
-	 */
-	public static Button createRadioButton(Composite parent, String label,
-			int gridDataFill, int horizontalSpan) {
-		Button button = new Button(parent, SWT.RADIO | SWT.LEFT);
-		GridData data = new GridData(gridDataFill);
-		data.horizontalSpan = horizontalSpan;
-		button.setLayoutData(data);
-		button.setText(label);
-		return button;
-	}
-
-	/**
-	 * Utility method that creates an empty line
-	 * 
-	 * @param parent
-	 *            the parent for the new label
-	 * @param numColumns
-	 *            the number of columns for the new composite
-	 */
-	public static void createSpacer(Composite parent, int numColumns) {
-		createSpacer(parent, numColumns, 0);
-	}
-
-	/**
-	 * Utility method that creates an empty line
-	 * 
-	 * @param parent
-	 *            the parent for the new label
-	 * @param numColumns
-	 *            the number of columns for the new composite
-	 * @param minWidth
-	 *            minimum width of spacer
-	 */
-	public static void createSpacer(Composite parent, int numColumns,
-			int minWidth) {
-		Label label = new Label(parent, SWT.NONE);
-		GridData data = new GridData();
-		data.horizontalSpan = numColumns;
-		data.widthHint = minWidth;
-		label.setLayoutData(data);
-	}
-
-	/**
-	 * Create a separator that goes across the entire page
-	 * 
-	 * @param parent
-	 *            the parent for the new label
-	 * @param numColumns
-	 *            the number of columns for the new composite
-	 */
-	public static void createSeparator(Composite parent, int numColumns) {
-		Label separator = new Label(parent, SWT.SEPARATOR | SWT.HORIZONTAL);
-		GridData data = new GridData();
-		data.horizontalSpan = numColumns;
-		data.horizontalAlignment = GridData.FILL;
-		data.grabExcessHorizontalSpace = true;
-		separator.setLayoutData(data);
-	}
-
-	/**
-	 * Create a table from a Composite object
-	 * 
-	 * @param composite
-	 *            the Composite this table is to be created from
-	 * @param tokenString
-	 *            A string containing names of the columns in the order that
-	 *            they should be displayed in the table with each column
-	 *            separated by a comma(',') or null if no columns need to be
-	 *            created.
-	 * @param tablewidth
-	 *            the minimum width for the table
-	 * @param tableHeight 
-	 * @return the new table
-	 */
-	public static Table createTable(Composite composite, String tokenString,
-			int tablewidth, int tableHeight) {
-		// SINGLE, MULTI, CHECK, FULL_SELECTION, HIDE_SELECTION
-		int style = SWT.V_SCROLL | SWT.H_SCROLL | SWT.SINGLE | SWT.BORDER
-				| SWT.FULL_SELECTION;
-		Table table = new Table(composite, style);
-		GridData gridData = new GridData(GridData.FILL_BOTH);
-		if (tablewidth > 0) {
-			gridData.widthHint = tablewidth;
-		}
-		if (tableHeight > 0) {
-			gridData.heightHint = tableHeight;
-		}
-		table.setLayoutData(gridData);
-		table.setHeaderVisible(true);
-		table.setLinesVisible(true);
-
-		if (tokenString != null) {
-			String[] columns = getTokenNames(tokenString);
-
-			int columnSize = 50;
-			if (tablewidth > 0) {
-				columnSize = tablewidth / columns.length;
-			}
-			for (int ii = 0; ii < columns.length; ii++) {
-				/*(void)*/ createTableColumn(table, columns[ii], ii,
-						columnSize);
-			}
-		}
-
-		return table;
-	}
-
-	/**
-	 * Create a table from a Composite object
-	 * 
-	 * @param composite
-	 *            the Composite this table is to be created from
-	 * @param columns
-	 *            A string array containing names of the columns in the order
-	 *            that they should be displayed in the table, or null if no
-	 *            columns need to be created.
-	 * @param tablewidth
-	 *            the minimum width for the table
-	 * @return the new table
-	 */
-	public static Table createTable(Composite composite, String[] columns,
-			int tablewidth) {
-		int style = SWT.BORDER | SWT.FULL_SELECTION;
-		Table table = new Table(composite, style);
-		GridData gridData = new GridData(GridData.FILL_BOTH);
-		gridData.widthHint = tablewidth;
-		table.setLayoutData(gridData);
-		table.setHeaderVisible(true);
-		table.setLinesVisible(true);
-
-		if (columns != null) {
-			for (int i = 0; i < columns.length; i++) {
-				/*(void)*/ createTableColumn(table, columns[i], i);
-			}
-		}
-
-		return table;
-	}
-
-	/**
-	 * Create a table column
-	 * 
-	 * @param parent
-	 *            the table that contains this column
-	 * @param name
-	 *            name of this column
-	 * @param index
-	 *            the column within the parent composite
-	 * @return the new table column
-	 */
-	public static TableColumn createTableColumn(Table parent, String name,
-			int index) {
-		TableColumn column = new TableColumn(parent, SWT.LEFT, index);
-		column.setText(name);
-		return column;
-	}
-
-	/**
-	 * Create a table column with the image and the width of the column is set
-	 * to the image width.
-	 * 
-	 * @param parent
-	 *            the table that contains this column
-	 * @param image
-	 *            iamge for this column
-	 * @param index 
-	 * @return the new table column
-	 */
-	public static TableColumn createTableColumn(Table parent, Image image,
-			int index) {
-		TableColumn column = new TableColumn(parent, SWT.LEFT, index);
-		column.setImage(image);
-		column.setWidth(image.getBounds().width);
-		column.setResizable(false);
-		return column;
-	}
-
-	/**
-	 * Create a table column
-	 * 
-	 * @param parent
-	 *            the table that contains this column
-	 * @param name
-	 *            name of this column
-	 * @param index
-	 *            the column within the parent composite
-	 * @param tablewidth
-	 *            the width for the column
-	 * @return the new table column
-	 */
-	public static TableColumn createTableColumn(Table parent, String name,
-			int index, int tablewidth) {
-		TableColumn column = new TableColumn(parent, SWT.LEFT, index);
-		column.setText(name);
-		column.setWidth(tablewidth);
-		return column;
-	}
-
-	/**
-	 * Create a text field
-	 * 
-	 * @param parent
-	 *            the parent of the new text field
-	 * @return the new text field
-	 */
-	public static Text createTextBox(Composite parent) {
-		return createTextBox(parent, 1, DEFAULT_TEXTBOX_WIDTH);
-	}
-
-	/**
-	 * Create a text field
-	 * 
-	 * @param parent
-	 *            the parent of the new text field
-	 * @param text 
-	 * @return the new text field
-	 */
-	public static Text createTextBox(Composite parent, String text) {
-		Text textbox = createTextBox(parent, 1);
-		textbox.setText(text);
-		return textbox;
-	}
-
-	/**
-	 * Create a text field
-	 * 
-	 * @param parent
-	 *            the parent of the new text field
-	 * @param numColumns
-	 *            number of columns the text box is to occupy
-	 * @return the new text field
-	 */
-	public static Text createTextBox(Composite parent, int numColumns) {
-		return createTextBox(parent, numColumns, DEFAULT_TEXTBOX_WIDTH);
-	}
-
-	/**
-	 * Create a text field
-	 * 
-	 * @param parent
-	 *            the parent of the new text field
-	 * @param numColumns
-	 *            number of columns the text box is to occupy
-	 * @param minWidth
-	 *            minimum width of text field
-	 * @return the new text field
-	 */
-	public static Text createTextBox(Composite parent, int numColumns,
-			int minWidth) {
-		return createTextBox(parent, numColumns, minWidth, SWT.DEFAULT);
-	}
-
-	/**
-	 * Create a text field
-	 * 
-	 * @param parent
-	 *            the parent of the new text field
-	 * @param numColumns
-	 *            number of columns the text box is to occupy
-	 * @param minWidth
-	 *            minimum width of text field
-	 * @param minHeight 
-	 * @return the new text field
-	 */
-	public static Text createTextBox(Composite parent, int numColumns,
-			int minWidth, int minHeight) {
-		Text text = new Text(parent, SWT.SINGLE | SWT.BORDER);
-		GridData data = new GridData(GridData.FILL);
-		data.horizontalSpan = numColumns;
-		data.widthHint = minWidth;
-		data.heightHint = minHeight;
-		text.setLayoutData(data);
-		return text;
-	}
-
-	/**
-	 * Create a text field that is scrollable.
-	 * 
-	 * @param parent
-	 *            the parent of the new text field
-	 * @param numColumns
-	 *            number of columns the text box is to occupy
-	 * @param minWidth
-	 *            minimum width of text field
-	 * @param minHeight
-	 *            minimum height of text field
-	 * @return the new text field
-	 */
-	public static Text createTextBoxScrollable(Composite parent,
-			int numColumns, int minWidth, int minHeight) {
-		Text text = new Text(parent, SWT.BORDER | SWT.V_SCROLL | SWT.WRAP);
-		GridData data = new GridData((minWidth > 0) ? GridData.FILL
-				: GridData.FILL_HORIZONTAL);
-		data.horizontalSpan = numColumns;
-		if (minWidth > 0) {
-			data.widthHint = minWidth;
-		}
-		data.heightHint = minHeight;
-
-		text.setLayoutData(data);
-		return text;
-	}
-
-	/**
-	 * Create a list with the items listed in it.
-	 * 
-	 * @param parent
-	 *            the parent of the new text field
-	 * @param numColumns
-	 *            number of columns the text box is to occupy
-	 * @param minWidth
-	 *            minimum width of text field
-	 * @param minHeight
-	 *            minimum height of text field
-	 * @param items
-	 *            the items in the list
-	 * @return the new list
-	 */
-	public static List createList(Composite parent, int numColumns,
-			int minWidth, int minHeight, String[] items) {
-		return createList(parent, numColumns, minWidth, minHeight, items, true);
-	}
-
-	/**
-	 * Create a list with the items listed in it.
-	 * 
-	 * @param parent
-	 *            the parent of the new list box
-	 * @param numColumns
-	 *            number of columns the list box is to occupy
-	 * @param minWidth
-	 *            minimum width of list box
-	 * @param minHeight
-	 *            minimum height of list box
-	 * @param items
-	 *            the items in the list
-	 * @param bmulti
-	 *            whether multiple item selection is allowed
-	 * @return the new list
-	 */
-	public static List createList(Composite parent, int numColumns,
-			int minWidth, int minHeight, String[] items, boolean bmulti) {
-		return createList(parent, numColumns, minWidth, minHeight, items,
-				bmulti, 1);
-	}
-
-	/**
-	 * Create a list with the items listed in it.
-	 * 
-	 * @param parent
-	 *            the parent of the new list box
-	 * @param numColumns
-	 *            number of columns the list box is to occupy
-	 * @param minWidth
-	 *            minimum width of list box
-	 * @param minHeight
-	 *            minimum height of list box
-	 * @param items
-	 *            the items in the list
-	 * @param bmulti
-	 *            whether multiple item selection is allowed
-	 * @param verticalSpan
-	 *            the number of rows the list box is to occupy
-	 * @return the new list
-	 */
-	public static List createList(Composite parent, int numColumns,
-			int minWidth, int minHeight, String[] items, boolean bmulti,
-			int verticalSpan) {
-		List theList;
-		if (bmulti)
-			theList = new List(parent, SWT.V_SCROLL | SWT.H_SCROLL | SWT.MULTI
-					| SWT.BORDER);
-		else
-			theList = new List(parent, SWT.V_SCROLL | SWT.H_SCROLL | SWT.SINGLE
-					| SWT.BORDER);
-		GridData data = new GridData(GridData.FILL_HORIZONTAL
-				| GridData.VERTICAL_ALIGN_BEGINNING | GridData.FILL_VERTICAL);
-		data.horizontalSpan = numColumns;
-		data.widthHint = minWidth;
-		data.heightHint = minHeight;
-		data.verticalSpan = verticalSpan;
-		theList.setLayoutData(data);
-		if (items != null) {
-			theList.setItems(items);
-		}
-
-		return theList;
-	}
-
-	/**
-	 * Computes the size of the composite inside the scroll area so that scroll
-	 * bars show up correctly.
-	 * 
-	 * @param parentComposite
-	 * @param childComposite
-	 */
-	public static void computeScrollArea(ScrolledComposite parentComposite,
-			Composite childComposite) {
-		// Point pt = childComposite.computeSize(SWT.DEFAULT, SWT.DEFAULT);
-		// childComposite.setSize(pt);
-
-		Point pt = childComposite.computeSize(SWT.DEFAULT, SWT.DEFAULT);
-		parentComposite.setExpandHorizontal(true);
-		parentComposite.setExpandVertical(true);
-		parentComposite.setMinWidth(pt.x);
-		parentComposite.setMinHeight(pt.y);
-	}
-
-	/**
-	 * Builds an array of strings from a token list string. The token separator
-	 * is a comma (',').
-	 * 
-	 * @param tokenString
-	 * @return String[]
-	 */
-	public static String[] getTokenNames(String tokenString) {
-		if (tokenString == null) {
-			return new String[0];
-		}
-
-		return tokenString.split(","); //$NON-NLS-1$
-	}
-
-	/**
-	 * Enable/Disable the widget and all its children.
-	 * 
-	 * @param widget
-	 *            The widget to be enabled/disabled.
-	 * @param state
-	 *            Enable widget if true. Disable otherwise.
-	 */
-	public static void setWidgetState(Control widget, boolean state) {
-		if (widget instanceof Composite) {
-			Control widgets[] = ((Composite) widget).getChildren();
-			for (int i = 0; i < widgets.length; i++) {
-				setWidgetState(widgets[i], state);
-			}
-		}
-		widget.setEnabled(state);
-	}
-
-	// ---------------------------------------------------------------------------
-	// following is for workaround eclipse problem
-	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=40281
-	static ControlListener _listener = new ControlListener() {
-		public void controlResized(ControlEvent e) {
-			final Composite c = (Composite) e.widget;
-			c.getDisplay().asyncExec(new Runnable() {
-				public void run() {
-					if (!c.isDisposed()) {
-						// XXX: in 3.0, should use c.layout(true)
-						// in 3.1, should use c.layout(true, true)
-						c.layout(true);
-						c.redraw();
-					}
-				}
-			});
-		}
-
-		public void controlMoved(ControlEvent e) {
-		    // nothing for move
-		}
-	};
-
-	/**
-	 * @param composite
-	 */
-	public static void workaroundResize(Composite composite) {
-		composite.addControlListener(_listener);
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/TextWindow.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/TextWindow.java
deleted file mode 100644
index b829cd2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/TextWindow.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.guiutils;
-
-import org.eclipse.jface.text.Document;
-import org.eclipse.jface.text.TextViewer;
-import org.eclipse.jface.window.ApplicationWindow;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.graphics.Point;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Shell;
-
-/**
- * Brings up a simple text window.
- * 
- * @author mengbo
- */
-public class TextWindow extends ApplicationWindow {
-	private String _content;
-
-	private Point _size = new Point(600, 600);
-
-	/**
-	 * empty for passing from events.
-	 * @param parentShell 
-	 * @param content 
-	 */
-	public TextWindow(Shell parentShell, String content) {
-		super(parentShell);
-		// addStatusLine();
-		_content = content;
-		// addCoolBar(SWT.BORDER);
-		// addMenuBar();
-		// addToolBar(SWT.BORDER);
-	}
-
-	protected Control createContents(Composite parent) {
-		// _text = new Text(parent, SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL);
-		// _text.setText(_content);
-		// return _text;
-
-		TextViewer tview = new TextViewer(parent, SWT.BORDER | SWT.V_SCROLL
-				| SWT.H_SCROLL);
-		tview.setDocument(new Document(_content));
-
-		return tview.getControl();
-	}
-
-
-	protected Point getInitialSize() {
-		return _size;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/messages.properties b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/messages.properties
deleted file mode 100644
index 6291ec0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/guiutils/messages.properties
+++ /dev/null
@@ -1,3 +0,0 @@
-IntroductionSection_noIntroDescription=No Introduction page configuration found in the plugin.xml
-IntroductionSection_noIntroTitle=No Introduction
-BrowserWindow_loading=<b>Loading...</b>
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/logging/Logger.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/logging/Logger.java
deleted file mode 100644
index 3b71b83..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/logging/Logger.java
+++ /dev/null
@@ -1,215 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2004, 2005 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.logging;
-
-import java.text.MessageFormat;
-import java.util.ResourceBundle;
-
-import org.eclipse.core.runtime.ILog;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Platform;
-import org.eclipse.core.runtime.Status;
-import org.osgi.framework.Bundle;
-
-/**
- * A resource bundle driven logger
- *
- */
-public class Logger {
-	private ResourceBundle resourceBundle;
-
-	private ILog log;
-
-	private String bundleId;
-
-	/**
-	 * @param bundle
-	 * @param resourceBundle
-	 */
-	public Logger(Bundle bundle, ResourceBundle resourceBundle) {
-		log = Platform.getLog(bundle);
-		this.resourceBundle = resourceBundle;
-		bundleId = bundle.getSymbolicName();
-		if (resourceBundle == null) {
-			IStatus status = new Status(IStatus.ERROR, bundleId, IStatus.OK,
-					"The resource Bundle for logger could not be null!", null); //$NON-NLS-1$
-			log.log(status);
-		}
-	}
-	/**
-	 * @param key
-	 * @param arg0
-	 */
-	public void info(String key, String arg0) {
-		Object[] args = new Object[1];
-		args[0] = arg0;
-
-		MessageFormat formatter = new MessageFormat(getString(key));
-		String message = formatter.format(args);
-		IStatus status = new Status(IStatus.INFO, bundleId, IStatus.OK,
-				message, null);
-		log.log(status);
-	}
-
-	/**
-	 * @param message
-	 */
-	public void info(String message) {
-		IStatus status = new Status(IStatus.INFO, bundleId, IStatus.OK,
-				message, null);
-		log.log(status);
-	}
-
-	/**
-	 * @param key
-	 * @param e
-	 */
-	public void info(String key, Throwable e) {
-		String message = getString(key);
-		IStatus status = new Status(IStatus.INFO, bundleId, IStatus.OK,
-				message, e);
-		log.log(status);
-	}
-
-	/**
-	 * @param key
-	 * @param arg0
-	 * @param e
-	 */
-	public void info(String key, String arg0, Throwable e) {
-		Object[] args = new Object[1];
-		args[0] = arg0;
-
-		MessageFormat formatter = new MessageFormat(getString(key));
-		String message = formatter.format(args);
-		IStatus status = new Status(IStatus.INFO, bundleId, IStatus.OK,
-				message, null);
-		log.log(status);
-	}
-	
-	/**
-	 * @param key
-	 * @param arg0
-	 * @param arg1
-	 * @param e
-	 */
-	public void info(String key, String arg0, String arg1, Throwable e) {
-		Object[] args = new Object[1];
-		args[0] = arg0;
-		args[1] = arg1;
-
-		MessageFormat formatter = new MessageFormat(getString(key));
-		String message = formatter.format(args);
-		IStatus status = new Status(IStatus.INFO, bundleId, IStatus.OK,
-				message, e);
-		log.log(status);
-	}
-
-    /**
-     * @param key
-     */
-    public void error(String key) {
-        
-        String message = getString(key);
-        IStatus status = new Status(IStatus.ERROR, bundleId, IStatus.OK,
-                message, null);
-        log.log(status);
-    }
-
-	/**
-	 * @param e
-	 */
-	public void error(Throwable e) {
-		IStatus status = new Status(IStatus.ERROR, bundleId, IStatus.OK, "", e); //$NON-NLS-1$
-		log.log(status);
-	}
-
-	/**
-	 * @param key
-	 * @param e
-	 */
-	public void error(String key, Throwable e) {
-		String message = getString(key);
-		IStatus status = new Status(IStatus.ERROR, bundleId, IStatus.OK,
-				message, e);
-		log.log(status);
-	}
-	
-	/**
-	 * @param key
-	 * @param arg0
-	 */
-	public void error(String key, String arg0) {
-		Object[] args = new Object[1];
-		args[0] = arg0;
-
-		MessageFormat formatter = new MessageFormat(getString(key));
-		String message = formatter.format(args);
-		IStatus status = new Status(IStatus.ERROR, bundleId, IStatus.OK,
-				message, null);
-		log.log(status);
-	}
-
-	/**
-	 * @param key
-	 * @param arg
-	 * @param e
-	 */
-	public void error(String key, String arg, Throwable e) {
-		Object[] args = new Object[1];
-		args[0] = arg;
-
-		MessageFormat formatter = new MessageFormat(getString(key));
-		String message = formatter.format(args);
-		IStatus status = new Status(IStatus.ERROR, bundleId, IStatus.OK,
-				message, e);
-		log.log(status);
-	}
-
-	/**
-	 * @param key
-	 * @param arg0
-	 * @param arg1
-	 * @param e
-	 */
-	public void error(String key, String arg0, String arg1, Throwable e) {
-		Object[] args = new Object[1];
-		args[0] = arg0;
-		args[1] = arg1;
-
-		MessageFormat formatter = new MessageFormat(getString(key));
-		String message = formatter.format(args);
-		IStatus status = new Status(IStatus.ERROR, bundleId, IStatus.OK,
-				message, e);
-		log.log(status);
-	}
-    
-    /**
-     * @param key
-     * @return the resource for the key, or an error message if
-     * resourceBundle.getString(key) throws an Exception
-     */
-    private String getString(String key)
-    {
-        try
-        {
-            return resourceBundle.getString(key);
-        }
-        // suppress non-error exceptions so that the logging operation
-        // itself (usually called in response to an exception) does not
-        // throw a new exception
-        catch(Exception e)
-        {
-            return "!!missing resource: " + key + "!!"; //$NON-NLS-1$ //$NON-NLS-2$
-        }
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/preferences/OrderingMessages.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/preferences/OrderingMessages.java
deleted file mode 100644
index 8202245..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/preferences/OrderingMessages.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.preferences;
-
-import org.eclipse.osgi.util.NLS;
-
-/**
- * @author cbateman
- *
- */
-public class OrderingMessages extends NLS
-{
-    private static final String BUNDLE_NAME= "org.eclipse.jst.jsf.common.ui.internal.preferences.OrderingMessages";//$NON-NLS-1$
-
-    private OrderingMessages() {
-        // Do not instantiate
-    }
-
-    /**
-     * see OrderMessages.properties
-     */
-    public static String Ordering_Up;
-    /**
-     * see OrderMessages.properties
-     */
-    public static String Ordering_Down;
-    
-    static {
-        NLS.initializeMessages(BUNDLE_NAME, OrderingMessages.class);
-    }
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/preferences/OrderingMessages.properties b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/preferences/OrderingMessages.properties
deleted file mode 100644
index 282ee23..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/preferences/OrderingMessages.properties
+++ /dev/null
@@ -1,12 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2008 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-Ordering_Up=Up
-Ordering_Down=Down
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/preferences/StrategyOrderingPanel.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/preferences/StrategyOrderingPanel.java
deleted file mode 100644
index c438b96..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/preferences/StrategyOrderingPanel.java
+++ /dev/null
@@ -1,322 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.preferences;
-
-import org.eclipse.core.runtime.Assert;
-import org.eclipse.jface.dialogs.IDialogConstants;
-import org.eclipse.jface.resource.JFaceResources;
-import org.eclipse.jface.viewers.CheckStateChangedEvent;
-import org.eclipse.jface.viewers.CheckboxTableViewer;
-import org.eclipse.jface.viewers.ICheckStateListener;
-import org.eclipse.jface.viewers.IStructuredContentProvider;
-import org.eclipse.jface.viewers.IStructuredSelection;
-import org.eclipse.jface.viewers.ITableLabelProvider;
-import org.eclipse.jface.viewers.Viewer;
-import org.eclipse.jst.jsf.common.internal.policy.OrderedListProvider;
-import org.eclipse.jst.jsf.common.internal.policy.OrderedListProvider.OrderableObject;
-import org.eclipse.jst.jsf.common.ui.internal.utils.PixelConverter;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.SelectionAdapter;
-import org.eclipse.swt.events.SelectionEvent;
-import org.eclipse.swt.graphics.GC;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.layout.GridLayout;
-import org.eclipse.swt.widgets.Button;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Label;
-import org.eclipse.swt.widgets.Table;
-import org.eclipse.swt.widgets.TableColumn;
-
-/**
- * Creates a composite with a checked table viewer and up/down buttons that
- * allow ordering and enablement of a list of items in the table.
- * 
- * Largely derived from
- * org.eclipse.jdt.internal.ui.preferences.CodeAssistAdvancedConfigurationBlock
- * 
- * @author cbateman
- * 
- */
-public class StrategyOrderingPanel
-{
-    private CheckboxTableViewer       _viewer;
-    private Button                    fUpButton;
-    private Button                    fDownButton;
-
-    private final OrderedListProvider _provider;
-    private final ITableLabelProvider _labelProvider;
-    private final String              _title;
-
-    /**
-     * @param provider
-     * @param labelProvider
-     * @param title 
-     */
-    public StrategyOrderingPanel(final OrderedListProvider provider,
-            final ITableLabelProvider labelProvider, final String title)
-    {
-        _provider = provider;
-        _labelProvider = labelProvider;
-        _title = title;
-    }
-
-    /**
-     * @param parent
-     * @return the control
-     */
-    public Control createContents(final Composite parent)
-    {
-        final Composite panel = new Composite(parent, SWT.NONE);
-        final GridLayout layout = new GridLayout(2, false);
-        layout.marginWidth = 0;
-        layout.marginHeight = 0;
-        panel.setLayout(layout);
-
-        final Label titleLabel = new Label(panel, SWT.NONE);
-        titleLabel.setText(_title);
-        final GridData gridData = new GridData(GridData.FILL,
-                GridData.BEGINNING, true, false, 2, 1);
-        titleLabel.setLayoutData(gridData);
-
-        createTableViewer(panel);
-        createButtonList(panel);
-
-        return panel;
-    }
-
-    /**
-     * Refresh the UI from model. Must not be called before createContents
-     */
-    public void refresh()
-    {
-        _provider.resetOrderedObjects();
-        _viewer.refresh();
-        for (final OrderableObject object : _provider.getOrderedObjects())
-        {
-            _viewer.setChecked(object, object.isEnabled());
-        }
-    }
-
-    private void createTableViewer(final Composite parent)
-    {
-        _viewer = CheckboxTableViewer.newCheckList(parent, SWT.SINGLE
-                | SWT.BORDER);
-        final Table table = _viewer.getTable();
-        table.setHeaderVisible(false);
-        table.setLinesVisible(false);
-        table.setLayoutData(new GridData(GridData.FILL, GridData.BEGINNING,
-                true, false, 1, 1));
-
-        final TableColumn nameColumn = new TableColumn(table, SWT.NONE);
-        // nameColumn
-        // .setText(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_separate_table_category_column_title);
-        nameColumn.setResizable(false);
-
-        _viewer.setContentProvider(new ContentProvider());
-
-        _viewer.setLabelProvider(_labelProvider);
-        _viewer.setInput(_provider);
-
-        final int ICON_AND_CHECKBOX_WITH = 50;
-        final int HEADER_MARGIN = 20;
-        int minNameWidth = computeWidth(table, nameColumn.getText())
-                + HEADER_MARGIN;
-        for (int i = 0; i < _provider.getOrderedObjects().size(); i++)
-        {
-            minNameWidth = Math.max(minNameWidth, computeWidth(table,
-                    _labelProvider.getColumnText(_provider.getOrderedObjects()
-                            .get(i), 0))
-                    + ICON_AND_CHECKBOX_WITH);
-        }
-
-        nameColumn.setWidth(minNameWidth);
-
-        _viewer.addCheckStateListener(new ICheckStateListener()
-        {
-            public void checkStateChanged(final CheckStateChangedEvent event)
-            {
-                final boolean checked = event.getChecked();
-                final OrderableObject element = (OrderableObject) event
-                        .getElement();
-                element.setEnabled(checked);
-            }
-        });
-
-        table.addSelectionListener(new SelectionAdapter()
-        {
-            @Override
-            public void widgetSelected(final SelectionEvent e)
-            {
-                handleTableSelection();
-            }
-        });
-
-    }
-
-    private void createButtonList(final Composite parent)
-    {
-        final Composite composite = new Composite(parent, SWT.NONE);
-        composite.setLayoutData(new GridData(SWT.BEGINNING, SWT.BEGINNING,
-                false, false));
-
-        final GridLayout layout = new GridLayout();
-        layout.marginWidth = 0;
-        layout.marginHeight = 0;
-        composite.setLayout(layout);
-
-        fUpButton = new Button(composite, SWT.PUSH | SWT.CENTER);
-        fUpButton.setText(OrderingMessages.Ordering_Up);
-        fUpButton.addSelectionListener(new SelectionAdapter()
-        {
-            @Override
-            public void widgetSelected(final SelectionEvent e)
-            {
-                final int index = getSelectionIndex();
-                if (index != -1)
-                {
-                    final OrderableObject object = _provider
-                            .getOrderedObjects().get(index);
-                    _provider.moveUp(object);
-                    _viewer.refresh();
-                    handleTableSelection();
-                }
-            }
-        });
-        fUpButton.setLayoutData(new GridData());
-        setButtonDimensionHint(fUpButton);
-
-        fDownButton = new Button(composite, SWT.PUSH | SWT.CENTER);
-        fDownButton.setText(OrderingMessages.Ordering_Down);
-        fDownButton.addSelectionListener(new SelectionAdapter()
-        {
-            @Override
-            public void widgetSelected(final SelectionEvent e)
-            {
-                final int index = getSelectionIndex();
-                if (index != -1)
-                {
-                    final OrderableObject object = _provider
-                            .getOrderedObjects().get(index);
-                    _provider.moveDown(object);
-                    _viewer.refresh();
-                    handleTableSelection();
-                }
-            }
-        });
-        fDownButton.setLayoutData(new GridData());
-        setButtonDimensionHint(fDownButton);
-    }
-
-    private int computeWidth(final Control control, final String name)
-    {
-        if (name == null)
-        {
-            return 0;
-        }
-        final GC gc = new GC(control);
-        try
-        {
-            gc.setFont(JFaceResources.getDialogFont());
-            return gc.stringExtent(name).x + 10;
-        }
-        finally
-        {
-            gc.dispose();
-        }
-    }
-
-    private void handleTableSelection()
-    {
-        final OrderableObject item = getSelectedItem();
-        if (item != null)
-        {
-            final int index = getSelectionIndex();
-            fUpButton.setEnabled(index > 0);
-            fDownButton
-                    .setEnabled(index < _provider.getOrderedObjects().size() - 1);
-        }
-        else
-        {
-            fUpButton.setEnabled(false);
-            fDownButton.setEnabled(false);
-        }
-    }
-
-    private OrderableObject getSelectedItem()
-    {
-        return (OrderableObject) ((IStructuredSelection) _viewer.getSelection())
-                .getFirstElement();
-    }
-
-    private int getSelectionIndex()
-    {
-        return _viewer.getTable().getSelectionIndex();
-    }
-
-    /**
-     * Returns a width hint for a button control.
-     */
-    private static int getButtonWidthHint(final Button button)
-    {
-        button.setFont(JFaceResources.getDialogFont());
-        PixelConverter converter = new PixelConverter(button);
-        final int widthHint = converter
-                .convertHorizontalDLUsToPixels(IDialogConstants.BUTTON_WIDTH);
-        return Math.max(widthHint, button.computeSize(SWT.DEFAULT, SWT.DEFAULT,
-                true).x);
-    }
-
-    /**
-     * Sets width and height hint for the button control. <b>Note:</b> This is
-     * a NOP if the button's layout data is not an instance of
-     * <code>GridData</code>.
-     * 
-     * @param button
-     *            the button for which to set the dimension hint
-     */
-    private static void setButtonDimensionHint(final Button button)
-    {
-        Assert.isNotNull(button);
-        final Object gd = button.getLayoutData();
-        if (gd instanceof GridData)
-        {
-            ((GridData) gd).widthHint = getButtonWidthHint(button);
-            ((GridData) gd).horizontalAlignment = GridData.FILL;
-        }
-    }
-
-    private static class ContentProvider implements IStructuredContentProvider
-    {
-
-        public Object[] getElements(final Object inputElement)
-        {
-            if (inputElement instanceof OrderedListProvider)
-            {
-                return ((OrderedListProvider) inputElement).getOrderedObjects()
-                        .toArray();
-            }
-            return new Object[0];
-        }
-
-        public void dispose()
-        {
-            // do nothing
-        }
-
-        public void inputChanged(final Viewer viewer, final Object oldInput,
-                final Object newInput)
-        {
-            // do nothing
-        }
-
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/FavoriteConfigurations.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/FavoriteConfigurations.java
deleted file mode 100644
index aa7744b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/FavoriteConfigurations.java
+++ /dev/null
@@ -1,257 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.utils;
-
-import java.io.FileNotFoundException;
-import java.io.FileReader;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Properties;
-
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.jst.jsf.common.ui.JSFUICommonPlugin;
-import org.eclipse.jst.jsf.common.ui.internal.logging.Logger;
-import org.eclipse.ui.IMemento;
-import org.eclipse.ui.XMLMemento;
-import org.eclipse.ui.plugin.AbstractUIPlugin;
-
-/**
- * This provides a means to store common properties for pages.
- * 
- * Holds a <code>List</code> of <code>Properties</code> which can be
- * manipulated by the user.
- * 
- * @author mengbo
- */
-public class FavoriteConfigurations {
-	private static Logger _log = JSFUICommonPlugin
-			.getLogger(FavoriteConfigurations.class);
-
-	private final static String FAV_EXTENSIONS = ".xml"; //$NON-NLS-1$
-
-	private final static String ELEMENT_ROOT = "favorite"; //$NON-NLS-1$
-
-	private final static String ELEMENT_CONFIG = "config"; //$NON-NLS-1$
-
-	private final static String ELEMENT_NAME = "name"; //$NON-NLS-1$
-
-	private final static String ELEMENT_PROPERTY = "property"; //$NON-NLS-1$
-
-	private final static String ELEMENT_VALUE = "value"; //$NON-NLS-1$
-
-	private Map _favorites;
-
-	private IPath _favoriteFile;
-
-	private String _favoriteName;
-
-	/**
-	 * Constructor
-	 * 
-	 * @param plugin
-	 *            used for location of favorite file.
-	 * @param favoriteName
-	 *            used for name of file and for mapping the properties of this
-	 *            favorite.
-	 */
-	public FavoriteConfigurations(AbstractUIPlugin plugin, String favoriteName) {
-		super();
-		_favoriteFile = plugin.getStateLocation().append(
-				scanFileName(favoriteName) + FAV_EXTENSIONS);
-		readFavorites();
-	}
-
-	/**
-	 * Returns the favorite entry that is mapped under the given name.
-	 * 
-	 * @param name
-	 *            the favorite
-	 * @return <code>Properties</code> config entry for the favorite.
-	 */
-	public Properties getFavorite(String name) {
-		return (Properties) _favorites.get(name);
-	}
-
-	/**
-	 * Stores the Favorites into the plugin directory.
-	 */
-	public void saveFavorites() {
-		FileWriter fw = null;
-		try {
-			XMLMemento memento = XMLMemento.createWriteRoot(ELEMENT_ROOT);
-			for (Iterator it = _favorites.keySet().iterator(); it.hasNext();) {
-				String favName = (String) it.next();
-				Map props = new HashMap((Properties) _favorites.get(favName));
-
-				IMemento config = memento.createChild(ELEMENT_CONFIG);
-				config.putString(ELEMENT_NAME, favName);
-
-				for (Iterator it1 = props.keySet().iterator(); it1.hasNext();) {
-					IMemento entry = config.createChild(ELEMENT_PROPERTY);
-					String name = (String) it1.next();
-					entry.putString(ELEMENT_NAME, name);
-					entry.putString(ELEMENT_VALUE, (String) props.get(name));
-				}
-			}
-			fw = new FileWriter(_favoriteFile.toFile());
-			memento.save(fw);
-		} catch (Exception ee) {
-			// log.FavoriteConfigurations.save.error=Failed to save {0}
-			// favorites. File={1}
-			_log.info("log.FavoriteConfigurations.save.error", _favoriteName, //$NON-NLS-1$
-					_favoriteFile.toOSString(), ee);
-		} finally {
-			if (fw != null) {
-				try {
-					fw.close();
-				} catch (IOException ee)// NOPMD
-				{
-					// nothing to do when IOException throwed in closing files.
-				}
-			}
-		}
-	}
-
-	/**
-	 * Add the favorite into the internal structure but don't save until
-	 * saveFavorites() is called.
-	 * 
-	 * @param name
-	 * @param config
-	 */
-	public void addFavorite(String name, Properties config) {
-		_favorites.put(name, config);
-	}
-
-	/**
-	 * Removes the Favorite that is mapped under the given name.
-	 * 
-	 * @param name
-	 *            the name of the configuration
-	 */
-	public void removeFavorite(String name) {
-		_favorites.remove(name);
-	}
-
-	/**
-	 * Read the favorites from the disk into the memory structure.
-	 */
-	protected void readFavorites() {
-		_favorites = new HashMap();
-		FileReader fr = null;
-		try {
-			try {
-				fr = new FileReader(_favoriteFile.toFile());
-			} catch (FileNotFoundException ee)// NOPMD
-			{
-				// no error here since they don't have to have a favorites...
-			}
-			if (fr != null) {
-				XMLMemento memento = XMLMemento.createReadRoot(fr);
-				IMemento[] children = memento.getChildren(ELEMENT_CONFIG);
-				for (int ii = 0; ii < children.length; ii++) {
-					Properties props = new Properties();
-					IMemento config = children[ii];
-					String name = config.getString(ELEMENT_NAME);
-
-					IMemento[] configProperties = config
-							.getChildren(ELEMENT_PROPERTY);
-					for (int jj = 0; jj < configProperties.length; jj++) {
-						IMemento entry = configProperties[jj];
-						setProperty(props, entry.getString(ELEMENT_NAME), entry
-								.getString(ELEMENT_VALUE));
-					}
-					_favorites.put(name, props);
-				}
-			}
-		} catch (Exception ee) {
-			// log.FavoriteConfigurations.read.error=Failed to save {0}
-			// favorites. File={1}
-			_log.error("log.FavoriteConfigurations.read.error", _favoriteName, //$NON-NLS-1$
-					_favoriteFile.toOSString(), ee);
-		} finally {
-			if (fr != null) {
-				try {
-					fr.close();
-				} catch (IOException ee)// NOPMD
-				{
-					// nothing to do when IOException throwed in closing files.
-				}
-			}
-		}
-	}
-
-	/**
-	 * Set the value in the properties object.
-	 * 
-	 * @param props
-	 * @param name
-	 * @param value
-	 */
-	private void setProperty(Properties props, String name, String value) {
-		if (name != null && value != null) {
-			props.setProperty(name, value);
-		}
-	}
-
-	/**
-	 * Get a list of all the favorites stored in this file.
-	 * 
-	 * @return list of favorites
-	 */
-	public String[] getFavoritesList() {
-		Object[] objs = _favorites.keySet().toArray();
-		String[] names = new String[objs.length];
-
-		for (int ii = 0; ii < objs.length; ii++) {
-			names[ii] = (String) objs[ii];
-		}
-		Arrays.sort(names);
-
-		return names;
-	}
-
-	/**
-	 * scan the file name for any bad character that would fail when trying to
-	 * create the file. We replace bad characters with '_'
-	 */
-	private static String scanFileName(String filename) {
-		StringBuffer strBuf = new StringBuffer();
-		char[] chars = filename.toCharArray();
-
-		for (int ii = 0; ii < chars.length; ii++) {
-			switch (chars[ii]) {
-			case '&':
-			case '\\':
-			case '/':
-			case ' ':
-			case '\t':
-			case ':':
-			case '.':
-			case '\"':
-			case '\'':
-			case '@':
-				strBuf.append('_');
-				break;
-			default:
-				strBuf.append(chars[ii]);
-				break;
-			}
-		}
-
-		return strBuf.toString();
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/JSFSharedImages.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/JSFSharedImages.java
deleted file mode 100644
index 2b67a67..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/JSFSharedImages.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.utils;
-
-/**
- * Constants that can be passed to JSFUICommonPlugin.getImageDescriptor and
- * getImage to obtain common images.
- * 
- * @author cbateman
- *
- */
-public interface JSFSharedImages
-{
-    /**
-     * The icon use for default/unknown tags.  Consists of blue open/close
-     * angled braces on a neutral background. 
-     * 
-     * Size: 16x16
-     */
-    public final static String DEFAULT_PALETTE_TAG_IMG = "PD_Palette_Default.gif"; //$NON-NLS-1$
-    
-    /**
-     * A yellow cube on a white background.  Suitable for representing 
-     * generic objects and components.
-     * 
-     * Size: 16x16
-     */
-    public final static String GENERIC_OBJECT_IMG = "object.gif"; //$NON-NLS-1$
-    
-    /**
-     * A generic image suitable for representing JSF validators.  Consists of
-     * a white box with a blue check mark.
-     * 
-     * Size: 16x16
-     */
-    public final static String GENERIC_VALIDATOR_IMG = "jsf_validator.gif"; //$NON-NLS-1$
-
-    /**
-     * A generic image suitable for representing JSF converter.  Consists of
-     * yellow blob being "converted".
-     * 
-     * Size: 16x16
-     */
-    public final static String GENERIC_CONVERTER_IMG = "jsf_converter.gif"; //$NON-NLS-1$
-
-    /**
-     * A generic image suitable for representing a view root.  Same as the
-     * default image generally associated with f:view.
-     * 
-     * Size: 16x16.
-     */
-    public static final String GENERIC_VIEWROOT_IMG = "jsf_view.gif"; //$NON-NLS-1$
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/JavaModelUtil.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/JavaModelUtil.java
deleted file mode 100644
index c4086ed..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/JavaModelUtil.java
+++ /dev/null
@@ -1,1032 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.utils;
-
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Set;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.jdt.core.ClasspathContainerInitializer;
-import org.eclipse.jdt.core.Flags;
-import org.eclipse.jdt.core.IClasspathContainer;
-import org.eclipse.jdt.core.IClasspathEntry;
-import org.eclipse.jdt.core.ICompilationUnit;
-import org.eclipse.jdt.core.IField;
-import org.eclipse.jdt.core.IImportDeclaration;
-import org.eclipse.jdt.core.IJavaElement;
-import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.core.IMember;
-import org.eclipse.jdt.core.IMethod;
-import org.eclipse.jdt.core.IPackageFragment;
-import org.eclipse.jdt.core.IPackageFragmentRoot;
-import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.core.ITypeHierarchy;
-import org.eclipse.jdt.core.JavaCore;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jdt.core.Signature;
-import org.eclipse.jdt.core.compiler.CharOperation;
-
-/**
- * Original code is from JDT Utility methods for the Java Model.
- */
-public final class JavaModelUtil {
-
-	/**
-	 * Finds a type by its qualified type name (dot separated).
-	 * 
-	 * @param jproject
-	 *            The java project to search in
-	 * @param fullyQualifiedName
-	 *            The fully qualified name (type name with enclosing type names
-	 *            and package (all separated by dots))
-	 * @return The type found, or null if not existing
-	 * @throws JavaModelException 
-	 */
-	public static IType findType(IJavaProject jproject,
-			String fullyQualifiedName) throws JavaModelException {
-		// workaround for bug 22883
-		IType type = jproject.findType(fullyQualifiedName);
-		if (type != null) {
-			return type;
-		}
-		IPackageFragmentRoot[] roots = jproject.getPackageFragmentRoots();
-		for (int i = 0; i < roots.length; i++) {
-			IPackageFragmentRoot root = roots[i];
-			type = findType(root, fullyQualifiedName);
-			if (type != null && type.exists()) {
-				return type;
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * Returns <code>true</code> if the given package fragment root is
-	 * referenced. This means it is own by a different project but is referenced
-	 * by the root's parent. Returns <code>false</code> if the given root
-	 * doesn't have an underlying resource.
-	 * @param root 
-	 * @return true if root is referenced
-	 */
-	public static boolean isReferenced(IPackageFragmentRoot root) {
-		IResource resource = root.getResource();
-		if (resource != null) {
-			IProject jarProject = resource.getProject();
-			IProject container = root.getJavaProject().getProject();
-			return !container.equals(jarProject);
-		}
-		return false;
-	}
-
-	private static IType findType(IPackageFragmentRoot root,
-			String fullyQualifiedName) throws JavaModelException {
-		IJavaElement[] children = root.getChildren();
-		for (int i = 0; i < children.length; i++) {
-			IJavaElement element = children[i];
-			if (element.getElementType() == IJavaElement.PACKAGE_FRAGMENT) {
-				IPackageFragment pack = (IPackageFragment) element;
-				if (!fullyQualifiedName.startsWith(pack.getElementName())) {
-					continue;
-				}
-				IType type = findType(pack, fullyQualifiedName);
-				if (type != null && type.exists()) {
-					return type;
-				}
-			}
-		}
-		return null;
-	}
-
-	private static IType findType(IPackageFragment pack,
-			String fullyQualifiedName) throws JavaModelException {
-		ICompilationUnit[] cus = pack.getCompilationUnits();
-		for (int i = 0; i < cus.length; i++) {
-			ICompilationUnit unit = cus[i];
-			IType type = findType(unit, fullyQualifiedName);
-			if (type != null && type.exists()) {
-				return type;
-			}
-		}
-		return null;
-	}
-
-	private static IType findType(ICompilationUnit cu, String fullyQualifiedName)
-			throws JavaModelException {
-		IType[] types = cu.getAllTypes();
-		for (int i = 0; i < types.length; i++) {
-			IType type = types[i];
-			if (getFullyQualifiedName(type).equals(fullyQualifiedName)) {
-				return type;
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * Finds a type by package and type name.
-	 * 
-	 * @param jproject
-	 *            the java project to search in
-	 * @param pack
-	 *            The package name
-	 * @param typeQualifiedName
-	 *            the type qualified name (type name with enclosing type names
-	 *            (separated by dots))
-	 * @return the type found, or null if not existing
-	 * @throws JavaModelException 
-	 * @deprecated Use IJavaProject.findType(String, String) instead
-	 */
-	public static IType findType(IJavaProject jproject, String pack,
-			String typeQualifiedName) throws JavaModelException {
-		return jproject.findType(pack, typeQualifiedName);
-	}
-
-	/**
-	 * Finds a type container by container name. The returned element will be of
-	 * type <code>IType</code> or a <code>IPackageFragment</code>.
-	 * <code>null</code> is returned if the type container could not be found.
-	 * 
-	 * @param jproject
-	 *            The Java project defining the context to search
-	 * @param typeContainerName
-	 *            A dot separarted name of the type container
-	 * @return the java element
-	 * @throws JavaModelException 
-	 * @see #getTypeContainerName(IType)
-	 */
-	public static IJavaElement findTypeContainer(IJavaProject jproject,
-			String typeContainerName) throws JavaModelException {
-		// try to find it as type
-		IJavaElement result = jproject.findType(typeContainerName);
-		if (result == null) {
-			// find it as package
-			IPath path = new Path(typeContainerName.replace('.', '/'));
-			result = jproject.findElement(path);
-			if (!(result instanceof IPackageFragment)) {
-				result = null;
-			}
-
-		}
-		return result;
-	}
-
-	/**
-	 * Finds a type in a compilation unit. Typical usage is to find the
-	 * corresponding type in a working copy.
-	 * 
-	 * @param cu
-	 *            the compilation unit to search in
-	 * @param typeQualifiedName
-	 *            the type qualified name (type name with enclosing type names
-	 *            (separated by dots))
-	 * @return the type found, or null if not existing
-	 * @throws JavaModelException 
-	 */
-	public static IType findTypeInCompilationUnit(ICompilationUnit cu,
-			String typeQualifiedName) throws JavaModelException {
-		IType[] types = cu.getAllTypes();
-		for (int i = 0; i < types.length; i++) {
-			String currName = getTypeQualifiedName(types[i]);
-			if (typeQualifiedName.equals(currName)) {
-				return types[i];
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * Finds a a member in a compilation unit. Typical usage is to find the
-	 * corresponding member in a working copy.
-	 * 
-	 * @param cu
-	 *            the compilation unit (eg. working copy) to search in
-	 * @param member
-	 *            the member (eg. from the original)
-	 * @return the member found, or null if not existing
-	 */
-	public static IMember findMemberInCompilationUnit(ICompilationUnit cu,
-			IMember member) {
-		IJavaElement[] elements = cu.findElements(member);
-		if (elements != null && elements.length > 0) {
-			return (IMember) elements[0];
-		}
-		return null;
-	}
-
-	/**
-	 * Returns the element of the given compilation unit which is "equal" to the
-	 * given element. Note that the given element usually has a parent different
-	 * from the given compilation unit.
-	 * 
-	 * @param cu
-	 *            the cu to search in
-	 * @param element
-	 *            the element to look for
-	 * @return an element of the given cu "equal" to the given element
-	 */
-	public static IJavaElement findInCompilationUnit(ICompilationUnit cu,
-			IJavaElement element) {
-		IJavaElement[] elements = cu.findElements(element);
-		if (elements != null && elements.length > 0) {
-			return elements[0];
-		}
-		return null;
-	}
-
-	/**
-	 * Returns the qualified type name of the given type using '.' as
-	 * separators. This is a replace for IType.getTypeQualifiedName() which uses
-	 * '$' as separators. As '$' is also a valid character in an id this is
-	 * ambiguous. JavaCore PR: 1GCFUNT
-	 * @param type 
-	 * @return the type qualified name
-	 */
-	public static String getTypeQualifiedName(IType type) {
-		return type.getTypeQualifiedName('.');
-	}
-
-	/**
-	 * Returns the fully qualified name of the given type using '.' as
-	 * separators. This is a replace for IType.getFullyQualifiedTypeName which
-	 * uses '$' as separators. As '$' is also a valid character in an id this is
-	 * ambiguous. JavaCore PR: 1GCFUNT
-	 * @param type 
-	 * @return the fully qualified name using . as the separator
-	 */
-	public static String getFullyQualifiedName(IType type) {
-		return type.getFullyQualifiedName('.');
-	}
-
-	/**
-	 * Returns the fully qualified name of a type's container. (package name or
-	 * enclosing type name)
-	 * @param type 
-	 * @return the container name
-	 */
-	public static String getTypeContainerName(IType type) {
-		IType outerType = type.getDeclaringType();
-		if (outerType != null) {
-			return outerType.getFullyQualifiedName('.');
-		}
-        return type.getPackageFragment().getElementName();
-	}
-
-	/**
-	 * Concatenates two names. Uses a dot for separation. Both strings can be
-	 * empty or <code>null</code>.
-	 * @param name1 
-	 * @param name2 
-	 * @return name1 + name2
-	 */
-	public static String concatenateName(String name1, String name2) {
-		StringBuffer buf = new StringBuffer();
-		if (name1 != null && name1.length() > 0) {
-			buf.append(name1);
-		}
-		if (name2 != null && name2.length() > 0) {
-			if (buf.length() > 0) {
-				buf.append('.');
-			}
-			buf.append(name2);
-		}
-		return buf.toString();
-	}
-
-	/**
-	 * Concatenates two names. Uses a dot for separation. Both strings can be
-	 * empty or <code>null</code>.
-	 * @param name1 
-	 * @param name2 
-	 * @return name1 + name2
-	 */
-	public static String concatenateName(char[] name1, char[] name2) {
-		StringBuffer buf = new StringBuffer();
-		if (name1 != null && name1.length > 0) {
-			buf.append(name1);
-		}
-		if (name2 != null && name2.length > 0) {
-			if (buf.length() > 0) {
-				buf.append('.');
-			}
-			buf.append(name2);
-		}
-		return buf.toString();
-	}
-
-	/**
-	 * Evaluates if a member (possible from another package) is visible from
-	 * elements in a package.
-	 * 
-	 * @param member
-	 *            The member to test the visibility for
-	 * @param pack
-	 *            The package in focus
-	 * @return true if visible
-	 * @throws JavaModelException 
-	 */
-	public static boolean isVisible(IMember member, IPackageFragment pack)
-			throws JavaModelException {
-
-		int type = member.getElementType();
-		if (type == IJavaElement.INITIALIZER
-				|| (type == IJavaElement.METHOD && member.getElementName()
-						.startsWith("<"))) { //$NON-NLS-1$
-			//$NON-NLS-1$
-			return false;
-		}
-
-		int otherflags = member.getFlags();
-		IType declaringType = member.getDeclaringType();
-		if (Flags.isPublic(otherflags)
-				|| (declaringType != null && declaringType.isInterface())) {
-			return true;
-		} else if (Flags.isPrivate(otherflags)) {
-			return false;
-		}
-
-		IPackageFragment otherpack = (IPackageFragment) findParentOfKind(
-				member, IJavaElement.PACKAGE_FRAGMENT);
-		return (pack != null && otherpack != null && isSamePackage(pack,
-				otherpack));
-	}
-
-	/**
-	 * Evaluates if a member in the focus' element hierarchy is visible from
-	 * elements in a package.
-	 * 
-	 * @param member
-	 *            The member to test the visibility for
-	 * @param pack
-	 *            The package of the focus element focus
-	 * @return true if is visible in hiearchy
-	 * @throws JavaModelException 
-	 */
-	public static boolean isVisibleInHierarchy(IMember member,
-			IPackageFragment pack) throws JavaModelException {
-		int type = member.getElementType();
-		if (type == IJavaElement.INITIALIZER
-				|| (type == IJavaElement.METHOD && member.getElementName()
-						.startsWith("<"))) { //$NON-NLS-1$
-			//$NON-NLS-1$
-			return false;
-		}
-
-		int otherflags = member.getFlags();
-
-		IType declaringType = member.getDeclaringType();
-		if (Flags.isPublic(otherflags) || Flags.isProtected(otherflags)
-				|| (declaringType != null && declaringType.isInterface())) {
-			return true;
-		} else if (Flags.isPrivate(otherflags)) {
-			return false;
-		}
-
-		IPackageFragment otherpack = (IPackageFragment) findParentOfKind(
-				member, IJavaElement.PACKAGE_FRAGMENT);
-		return (pack != null && pack.equals(otherpack));
-	}
-
-	/**
-	 * Returns the package fragment root of <code>IJavaElement</code>. If the
-	 * given element is already a package fragment root, the element itself is
-	 * returned.
-	 * @param element 
-	 * @return the package fragment root
-	 */
-	public static IPackageFragmentRoot getPackageFragmentRoot(
-			IJavaElement element) {
-		return (IPackageFragmentRoot) element
-				.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
-	}
-
-	/**
-	 * Returns the parent of the supplied java element that conforms to the
-	 * given parent type or <code>null</code>, if such a parent doesn't exit.
-	 * 
-	 * @deprecated Use element.getParent().getAncestor(kind);
-	 */
-	private static IJavaElement findParentOfKind(IJavaElement element, int kind) {
-		if (element != null && element.getParent() != null) {
-			return element.getParent().getAncestor(kind);
-		}
-		return null;
-	}
-
-	/**
-	 * Finds a method in a type. This searches for a method with the same name
-	 * and signature. Parameter types are only compared by the simple name, no
-	 * resolving for the fully qualified type name is done. Constructors are
-	 * only compared by parameters, not the name.
-	 * 
-	 * @param name
-	 *            The name of the method to find
-	 * @param paramTypes
-	 *            The type signatures of the parameters e.g.
-	 *            <code>{"QString;","I"}</code>
-	 * @param isConstructor
-	 *            If the method is a constructor
-	 * @param type 
-	 * @return The first found method or <code>null</code>, if nothing found
-	 * @throws JavaModelException 
-	 */
-	public static IMethod findMethod(String name, String[] paramTypes,
-			boolean isConstructor, IType type) throws JavaModelException {
-		return findMethod(name, paramTypes, isConstructor, type.getMethods());
-	}
-
-	/**
-	 * Finds a method by name. This searches for a method with a name and
-	 * signature. Parameter types are only compared by the simple name, no
-	 * resolving for the fully qualified type name is done. Constructors are
-	 * only compared by parameters, not the name.
-	 * 
-	 * @param name
-	 *            The name of the method to find
-	 * @param paramTypes
-	 *            The type signatures of the parameters e.g.
-	 *            <code>{"QString;","I"}</code>
-	 * @param isConstructor
-	 *            If the method is a constructor
-	 * @param methods
-	 *            The methods to search in
-	 * @return The found method or <code>null</code>, if nothing found
-	 * @throws JavaModelException 
-	 */
-	public static IMethod findMethod(String name, String[] paramTypes,
-			boolean isConstructor, IMethod[] methods) throws JavaModelException {
-		for (int i = methods.length - 1; i >= 0; i--) {
-			if (isSameMethodSignature(name, paramTypes, isConstructor,
-					methods[i])) {
-				return methods[i];
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * Finds a method declararion in a type's hierarchy. The search is top down,
-	 * so this returns the first declaration of the method in the hierarchy.
-	 * This searches for a method with a name and signature. Parameter types are
-	 * only compared by the simple name, no resolving for the fully qualified
-	 * type name is done. Constructors are only compared by parameters, not the
-	 * name.
-	 * @param hierarchy 
-	 * 
-	 * @param type
-	 *            Searches in this type's supertypes.
-	 * @param name
-	 *            The name of the method to find
-	 * @param paramTypes
-	 *            The type signatures of the parameters e.g.
-	 *            <code>{"QString;","I"}</code>
-	 * @param isConstructor
-	 *            If the method is a constructor
-	 * @return The first method found or null, if nothing found
-	 * @throws JavaModelException 
-	 */
-	public static IMethod findMethodDeclarationInHierarchy(
-			ITypeHierarchy hierarchy, IType type, String name,
-			String[] paramTypes, boolean isConstructor)
-			throws JavaModelException {
-		IType[] superTypes = hierarchy.getAllSupertypes(type);
-		for (int i = superTypes.length - 1; i >= 0; i--) {
-			IMethod first = findMethod(name, paramTypes, isConstructor,
-					superTypes[i]);
-			if (first != null && !Flags.isPrivate(first.getFlags())) {
-				// the order getAllSupertypes does make assumptions of the order
-				// of inner elements -> search recursivly
-				IMethod res = findMethodDeclarationInHierarchy(hierarchy, first
-						.getDeclaringType(), name, paramTypes, isConstructor);
-				if (res != null) {
-					return res;
-				}
-				return first;
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * Finds a method implementation in a type's classhierarchy. The search is
-	 * bottom-up, so this returns the nearest overridden method. Does not find
-	 * methods in interfaces or abstract methods. This searches for a method
-	 * with a name and signature. Parameter types are only compared by the
-	 * simple name, no resolving for the fully qualified type name is done.
-	 * Constructors are only compared by parameters, not the name.
-	 * @param hierarchy 
-	 * 
-	 * @param type
-	 *            Type to search the superclasses
-	 * @param name
-	 *            The name of the method to find
-	 * @param paramTypes
-	 *            The type signatures of the parameters e.g.
-	 *            <code>{"QString;","I"}</code>
-	 * @param isConstructor
-	 *            If the method is a constructor
-	 * @return The first method found or null, if nothing found
-	 * @throws JavaModelException 
-	 */
-	public static IMethod findMethodImplementationInHierarchy(
-			ITypeHierarchy hierarchy, IType type, String name,
-			String[] paramTypes, boolean isConstructor)
-			throws JavaModelException {
-		IType[] superTypes = hierarchy.getAllSuperclasses(type);
-		for (int i = 0; i < superTypes.length; i++) {
-			IMethod found = findMethod(name, paramTypes, isConstructor,
-					superTypes[i]);
-			if (found != null) {
-				if (Flags.isAbstract(found.getFlags())) {
-					return null;
-				}
-				return found;
-			}
-		}
-		return null;
-	}
-
-	private static IMethod findMethodInHierarchy(ITypeHierarchy hierarchy,
-			IType type, String name, String[] paramTypes, boolean isConstructor)
-			throws JavaModelException {
-		IMethod method = findMethod(name, paramTypes, isConstructor, type);
-		if (method != null) {
-			return method;
-		}
-		IType superClass = hierarchy.getSuperclass(type);
-		if (superClass != null) {
-			IMethod res = findMethodInHierarchy(hierarchy, superClass, name,
-					paramTypes, isConstructor);
-			if (res != null) {
-				return res;
-			}
-		}
-		if (!isConstructor) {
-			IType[] superInterfaces = hierarchy.getSuperInterfaces(type);
-			for (int i = 0; i < superInterfaces.length; i++) {
-				IMethod res = findMethodInHierarchy(hierarchy,
-						superInterfaces[i], name, paramTypes, false);
-				if (res != null) {
-					return res;
-				}
-			}
-		}
-		return method;
-	}
-
-	/**
-	 * Finds the method that is defines/declares the given method. The search is
-	 * bottom-up, so this returns the nearest defining/declaring method.
-	 * @param typeHierarchy 
-	 * @param type 
-	 * @param methodName 
-	 * @param paramTypes 
-	 * @param isConstructor 
-	 * 
-	 * @param testVisibility
-	 *            If true the result is tested on visibility. Null is returned
-	 *            if the method is not visible.
-	 * @return the method or null
-	 * @throws JavaModelException
-	 */
-	public static IMethod findMethodDefininition(ITypeHierarchy typeHierarchy,
-			IType type, String methodName, String[] paramTypes,
-			boolean isConstructor, boolean testVisibility)
-			throws JavaModelException {
-		IType superClass = typeHierarchy.getSuperclass(type);
-		if (superClass != null) {
-			IMethod res = findMethodInHierarchy(typeHierarchy, superClass,
-					methodName, paramTypes, isConstructor);
-			if (res != null && !Flags.isPrivate(res.getFlags())) {
-				if (!testVisibility
-						|| isVisibleInHierarchy(res, type.getPackageFragment())) {
-					return res;
-				}
-			}
-		}
-		if (!isConstructor) {
-			IType[] interfaces = typeHierarchy.getSuperInterfaces(type);
-			for (int i = 0; i < interfaces.length; i++) {
-				IMethod res = findMethodInHierarchy(typeHierarchy,
-						interfaces[i], methodName, paramTypes, false);
-				if (res != null) {
-					return res; // methods from interfaces are always public and
-					// therefore visible
-				}
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * Tests if a method equals to the given signature. Parameter types are only
-	 * compared by the simple name, no resolving for the fully qualified type
-	 * name is done. Constructors are only compared by parameters, not the name.
-	 * 
-	 * @param name
-	 *            Name of the method
-	 * @param paramTypes
-	 *            The type signatures of the parameters e.g.
-	 *            <code>{"QString;","I"}</code>
-	 * @param isConstructor
-	 *            Specifies if the method is a constructor
-	 * @param curr 
-	 * @return Returns <code>true</code> if the method has the given name and
-	 *         parameter types and constructor state.
-	 * @throws JavaModelException 
-	 */
-	public static boolean isSameMethodSignature(String name,
-			String[] paramTypes, boolean isConstructor, IMethod curr)
-			throws JavaModelException {
-		if (isConstructor || name.equals(curr.getElementName())) {
-			if (isConstructor == curr.isConstructor()) {
-				String[] currParamTypes = curr.getParameterTypes();
-				if (paramTypes.length == currParamTypes.length) {
-					for (int i = 0; i < paramTypes.length; i++) {
-						String t1 = Signature.getSimpleName(Signature
-								.toString(paramTypes[i]));
-						String t2 = Signature.getSimpleName(Signature
-								.toString(currParamTypes[i]));
-						if (!t1.equals(t2)) {
-							return false;
-						}
-					}
-					return true;
-				}
-			}
-		}
-		return false;
-	}
-
-	/**
-	 * Tests if two <code>IPackageFragment</code>s represent the same logical
-	 * java package.
-	 * @param pack1 
-	 * @param pack2 
-	 * 
-	 * @return <code>true</code> if the package fragments' names are equal.
-	 */
-	public static boolean isSamePackage(IPackageFragment pack1,
-			IPackageFragment pack2) {
-		return pack1.getElementName().equals(pack2.getElementName());
-	}
-
-	/**
-	 * Checks whether the given type has a valid main method or not.
-	 * @param type 
-	 * @return true if type has a main method
-	 * @throws JavaModelException 
-	 */
-	public static boolean hasMainMethod(IType type) throws JavaModelException {
-		IMethod[] methods = type.getMethods();
-		for (int i = 0; i < methods.length; i++) {
-			if (methods[i].isMainMethod()) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	/**
-	 * Checks if the field is boolean.
-	 * @param field 
-	 * @return true if the file is of primitive boolean type
-	 * @throws JavaModelException 
-	 */
-	public static boolean isBoolean(IField field) throws JavaModelException {
-		return field.getTypeSignature().equals(Signature.SIG_BOOLEAN);
-	}
-
-	/**
-	 * Tests if the given element is on the class path of its containing
-	 * project. Handles the case that the containing project isn't a Java
-	 * project.
-	 * @param element 
-	 * @return true if element in on the class path?
-	 */
-	public static boolean isOnClasspath(IJavaElement element) {
-		IJavaProject project = element.getJavaProject();
-		if (!project.exists())
-			return false;
-		return project.isOnClasspath(element);
-	}
-
-	/**
-	 * Resolves a type name in the context of the declaring type.
-	 * 
-	 * @param refTypeSig
-	 *            the type name in signature notation (for example 'QVector')
-	 *            this can also be an array type, but dimensions will be
-	 *            ignored.
-	 * @param declaringType
-	 *            the context for resolving (type where the reference was made
-	 *            in)
-	 * @return returns the fully qualified type name or build-in-type name. if a
-	 *         unresoved type couldn't be resolved null is returned
-	 * @throws JavaModelException 
-	 */
-	public static String getResolvedTypeName(String refTypeSig,
-			IType declaringType) throws JavaModelException {
-		int arrayCount = Signature.getArrayCount(refTypeSig);
-		char type = refTypeSig.charAt(arrayCount);
-		if (type == Signature.C_UNRESOLVED) {
-			int semi = refTypeSig
-					.indexOf(Signature.C_SEMICOLON, arrayCount + 1);
-			if (semi == -1) {
-				throw new IllegalArgumentException();
-			}
-			String name = refTypeSig.substring(arrayCount + 1, semi);
-
-			String[][] resolvedNames = declaringType.resolveType(name);
-			if (resolvedNames != null && resolvedNames.length > 0) {
-				return JavaModelUtil.concatenateName(resolvedNames[0][0],
-						resolvedNames[0][1]);
-			}
-			return null;
-		}
-        return Signature.toString(refTypeSig.substring(arrayCount));
-	}
-
-	/**
-	 * Returns if a CU can be edited.
-	 * @param cu 
-	 * @return true if cu is editable
-	 */
-	public static boolean isEditable(ICompilationUnit cu) {
-		IResource resource = toOriginal(cu).getResource();
-		return (resource.exists() && !resource.getResourceAttributes()
-				.isReadOnly());
-	}
-
-	/**
-	 * Finds a qualified import for a type name.
-	 * @param cu 
-	 * @param simpleName 
-	 * @return the import declaration or null
-	 * @throws JavaModelException 
-	 */
-	public static IImportDeclaration findImport(ICompilationUnit cu,
-			String simpleName) throws JavaModelException {
-		IImportDeclaration[] existing = cu.getImports();
-		for (int i = 0; i < existing.length; i++) {
-			String curr = existing[i].getElementName();
-			if (curr.endsWith(simpleName)) {
-				int dotPos = curr.length() - simpleName.length() - 1;
-				if ((dotPos == -1)
-						|| (dotPos > 0 && curr.charAt(dotPos) == '.')) {
-					return existing[i];
-				}
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * Returns the original if the given member. If the member is already an
-	 * original the input is returned. The returned member might not exist
-	 * @param member 
-	 * @return the original IMember
-	 */
-	public static IMember toOriginal(IMember member) {
-		if (member instanceof IMethod) {
-			return toOriginalMethod((IMethod) member);
-		}
-
-		return (IMember) member.getPrimaryElement();
-		/*
-		 * ICompilationUnit cu= member.getCompilationUnit(); if (cu != null &&
-		 * cu.isWorkingCopy()) return (IMember)cu.getOriginal(member); return
-		 * member;
-		 */
-	}
-
-	/*
-	 * XXX workaround for bug 18568
-	 * http://bugs.eclipse.org/bugs/show_bug.cgi?id=18568 to be removed once the
-	 * bug is fixed
-	 */
-	private static IMethod toOriginalMethod(IMethod method) {
-		ICompilationUnit cu = method.getCompilationUnit();
-		if (cu == null || isPrimary(cu)) {
-			return method;
-		}
-		try {
-			// use the workaround only if needed
-			if (!method.getElementName().equals(
-					method.getDeclaringType().getElementName()))
-				return (IMethod) method.getPrimaryElement();
-
-			IType originalType = (IType) toOriginal(method.getDeclaringType());
-			IMethod[] methods = originalType.findMethods(method);
-			boolean isConstructor = method.isConstructor();
-			for (int i = 0; i < methods.length; i++) {
-				if (methods[i].isConstructor() == isConstructor)
-					return methods[i];
-			}
-			return null;
-		} catch (JavaModelException e) {
-			return null;
-		}
-	}
-
-	// private static boolean PRIMARY_ONLY = false;
-
-	/**
-	 * Returns the original cu if the given cu is a working copy. If the cu is
-	 * already an original the input cu is returned. The returned cu might not
-	 * exist
-	 * @param cu 
-	 * @return the original compiliation unit
-	 */
-	public static ICompilationUnit toOriginal(ICompilationUnit cu) {
-		// To stay compatible with old version returned null
-		// if cu is null
-		if (cu == null)
-			return cu;
-		return cu.getPrimary();
-	}
-
-	/**
-	 * Returns the original element if the given element is a working copy. If
-	 * the cu is already an original the input element is returned. The returned
-	 * element might not exist
-	 * @param element 
-	 * @return element's primary element
-	 */
-	public static IJavaElement toOriginal(IJavaElement element) {
-		return element.getPrimaryElement();
-	}
-
-	/**
-	 * Returns true if a cu is a primary cu (original or shared working copy)
-	 * @param cu 
-	 * @return true if cu  is primary
-	 */
-	public static boolean isPrimary(ICompilationUnit cu) {
-		return cu.getOwner() == null;
-	}
-
-	/**
-	 * http://bugs.eclipse.org/bugs/show_bug.cgi?id=19253
-	 * 
-	 * Reconciling happens in a separate thread. This can cause a situation
-	 * where the Java element gets disposed after an exists test has been done.
-	 * So we should not log not present exceptions when they happen in working
-	 * copies.
-	 * @param exception 
-	 * @return true if filter not present
-	 */
-	public static boolean filterNotPresentException(CoreException exception) {
-		if (!(exception instanceof JavaModelException)) {
-			return true;
-		}
-		JavaModelException je = (JavaModelException) exception;
-		if (!je.isDoesNotExist()) {
-			return true;
-		}
-		IJavaElement[] elements = je.getJavaModelStatus().getElements();
-		for (int i = 0; i < elements.length; i++) {
-			IJavaElement element = elements[i];
-			ICompilationUnit unit = (ICompilationUnit) element
-					.getAncestor(IJavaElement.COMPILATION_UNIT);
-			if (unit == null) {
-				return true;
-			}
-			if (!unit.isWorkingCopy()) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	/**
-	 * @param type
-	 * @param pm
-	 * @return all supertypes of type
-	 * @throws JavaModelException
-	 */
-	public static IType[] getAllSuperTypes(IType type, IProgressMonitor pm)
-			throws JavaModelException {
-		// workaround for 23656
-		Set types = new HashSet(Arrays.asList(type.newSupertypeHierarchy(pm)
-				.getAllSupertypes(type)));
-		IType objekt = type.getJavaProject().findType("java.lang.Object");//$NON-NLS-1$
-		if (objekt != null) {
-			types.add(objekt);
-		}
-		return (IType[]) types.toArray(new IType[types.size()]);
-	}
-
-	/**
-	 * @param resourcePath
-	 * @param exclusionPatterns
-	 * @return true if resourcePath is excluded by exclusion patterns
-	 */
-	public static boolean isExcludedPath(IPath resourcePath,
-			IPath[] exclusionPatterns) {
-		char[] path = resourcePath.toString().toCharArray();
-		for (int i = 0, length = exclusionPatterns.length; i < length; i++) {
-			char[] pattern = exclusionPatterns[i].toString().toCharArray();
-			if (CharOperation.pathMatch(pattern, path, true, '/')) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	/*
-
-	 * @see IClasspathEntry#getExclusionPatterns
-	 */
-	/**
-	 * Returns whether the given resource path matches one of the exclusion
-	 * patterns.
-	 * 
-	 * @param resourcePath
-	 * @param exclusionPatterns
-	 * @return true if resourcePath is excluded
-	 */
-	public static boolean isExcluded(IPath resourcePath,
-			char[][] exclusionPatterns) {
-		if (exclusionPatterns == null) {
-			return false;
-		}
-		char[] path = resourcePath.toString().toCharArray();
-		for (int i = 0, length = exclusionPatterns.length; i < length; i++) {
-			if (CharOperation.pathMatch(exclusionPatterns[i], path, true, '/')) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	private static Boolean fgIsJDTCore_1_5 = null;
-
-	/**
-	 * @return true if JRE 1.5 in enabled.
-	 */
-	public static boolean isJDTCore_1_5() {
-		if (fgIsJDTCore_1_5 == null) {
-			fgIsJDTCore_1_5 = JavaCore
-					.getDefaultOptions()
-					.containsKey(
-							"org.eclipse.jdt.core.compiler.problem.unsafeTypeOperation") ? Boolean.TRUE //$NON-NLS-1$
-					: Boolean.FALSE;
-		}
-		return fgIsJDTCore_1_5.booleanValue();
-	}
-
-	/**
-	 * Helper method that tests if an classpath entry can be found in a
-	 * container. <code>null</code> is returned if the entry can not be found
-	 * or if the container does not allows the configuration of source
-	 * attachments
-	 * 
-	 * @param jproject
-	 *            The container's parent project
-	 * @param containerPath
-	 *            The path of the container
-	 * @param libPath
-	 *            The path of the library to be found
-	 * @return IClasspathEntry A classpath entry from the container of
-	 *         <code>null</code> if the container can not be modified.
-	 * @throws JavaModelException 
-	 */
-	public static IClasspathEntry getClasspathEntryToEdit(
-			IJavaProject jproject, IPath containerPath, IPath libPath)
-			throws JavaModelException {
-		IClasspathContainer container = JavaCore.getClasspathContainer(
-				containerPath, jproject);
-		ClasspathContainerInitializer initializer = JavaCore
-				.getClasspathContainerInitializer(containerPath.segment(0));
-		if (container != null
-				&& initializer != null
-				&& initializer.canUpdateClasspathContainer(containerPath,
-						jproject)) {
-			IClasspathEntry[] entries = container.getClasspathEntries();
-			for (int i = 0; i < entries.length; i++) {
-				IClasspathEntry curr = entries[i];
-				IClasspathEntry resolved = JavaCore
-						.getResolvedClasspathEntry(curr);
-				if (resolved != null && libPath.equals(resolved.getPath())) {
-					return curr; // return the real entry
-				}
-			}
-		}
-		return null; // attachment not possible
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/PathUtil.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/PathUtil.java
deleted file mode 100644
index 8eebe90..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/PathUtil.java
+++ /dev/null
@@ -1,307 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.utils;
-
-import java.io.File;
-import java.util.StringTokenizer;
-
-import org.eclipse.core.resources.IContainer;
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.resources.ResourcesPlugin;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.jdt.core.IClasspathEntry;
-import org.eclipse.jdt.core.IJarEntryResource;
-import org.eclipse.jdt.core.IJavaElement;
-import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jst.jsf.common.ui.IFileFolderConstants;
-import org.eclipse.ui.IFileEditorInput;
-import org.eclipse.ui.IWorkbenchPage;
-import org.eclipse.ui.IWorkbenchWindow;
-import org.eclipse.ui.PlatformUI;
-
-/**
- * Collection of helper methods to manage and convert links Originally part of
- * the LinksManager (com.ibm.iwt.parser.util)
- */
-public final class PathUtil {
-	private static final String FORWARD_SLASH = "/"; //$NON-NLS-1$
-
-	private static final String RELATIVE_PATH_SIGNAL = IFileFolderConstants.DOT
-			+ IFileFolderConstants.DOT + IFileFolderConstants.PATH_SEPARATOR;
-
-	/**
-	 * adjust relative path isside the absolute path
-	 * @param path 
-	 * @return the adjusted path
-	 */
-	public static String adjustPath(String path) {
-		int i = 0;
-		while ((i = path.indexOf(RELATIVE_PATH_SIGNAL)) > 0) {
-			// split the string into two
-			String part1 = path.substring(0, i - 1);
-			String part2 = path
-					.substring(i + RELATIVE_PATH_SIGNAL.length() - 1);
-			// strip one path seg from part1
-			int j = part1.lastIndexOf(FORWARD_SLASH);
-			if (j == -1) {
-				return "";//$NON-NLS-1$
-			}
-			part1 = part1.substring(0, j);
-			path = part1 + part2;
-		}
-		return path;
-	}
-
-	/**
-	 * Append trailing url slash if needed
-	 * @param input 
-	 * @return the string
-	 */
-	public static String appendTrailingURLSlash(String input) {
-		// check to see already a slash
-		if (!input.endsWith(FORWARD_SLASH)) {
-			input += FORWARD_SLASH;
-		}
-		return input;
-	}
-
-	/**
-	 * Convert to relative url based on base
-	 * @param input 
-	 * @param base 
-	 * @return the string
-	 */
-	public static String convertToRelativePath(String input, String base) {
-		// tokenize the strings
-		StringTokenizer inputTokenizer = new StringTokenizer(input,
-				FORWARD_SLASH);
-		StringTokenizer baseTokenizer = new StringTokenizer(base, FORWARD_SLASH);
-		String token1 = "", token2 = "";//$NON-NLS-2$//$NON-NLS-1$
-		//
-		// Go through until equls
-		while (true) {
-			if (!inputTokenizer.hasMoreTokens()
-					|| !baseTokenizer.hasMoreTokens()) {
-				break;
-			}
-			token1 = baseTokenizer.nextToken();
-			token2 = inputTokenizer.nextToken();
-			if (!token1.equals(token2)) {
-				break;
-			}
-		}
-		// now generate the backs
-		String output = "";//$NON-NLS-1$
-		while (baseTokenizer.hasMoreTokens()) {
-			baseTokenizer.nextToken();
-			output += RELATIVE_PATH_SIGNAL;
-		}
-		output += token2;
-		// generate the rest
-		while (inputTokenizer.hasMoreTokens()) {
-			output = output + FORWARD_SLASH + inputTokenizer.nextToken();
-		}
-		return output;
-	}
-
-	/**
-	 * @param projectName
-	 * @param path
-	 * @return the path in the project converted to a path relative to the
-	 * web folder
-	 */
-	public static String convertToWebPath(String projectName, String path) {
-		String name = ""; //$NON-NLS-1$
-		IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(
-				projectName);
-		String webrootName = WebrootUtil.getWebContentFolder(project).getName();
-
-		if (path.indexOf(webrootName) != -1) {
-			name = projectName + IFileFolderConstants.PATH_SEPARATOR
-					+ webrootName;
-		} else {
-			name = projectName;
-		}
-		int index = path.indexOf(projectName);
-
-		return path.substring(index + name.length());
-	}
-
-	/**
-	 * convert path relative to current active file to absolute path in
-	 * filesystem
-	 * 
-	 * @param uri
-	 *            the relative path
-	 * @param curFile 
-	 * @return absolute path in file system
-	 */
-	public static String convertToAbsolutePath(String uri, IFile curFile) {
-		if (uri == null || uri.trim().equals("")) { //$NON-NLS-1$
-			return uri;
-		}
-		String webroot = ""; //$NON-NLS-1$
-		IFile jsp = curFile;
-		try {
-			if (jsp == null) {
-				jsp = ((IFileEditorInput) getActivePage()
-						.getActiveEditor().getEditorInput()).getFile();
-			}
-			if (jsp != null) {
-				String webrootName = WebrootUtil.getWebContentFolder(
-						jsp.getProject()).getName();
-				webroot = jsp.getProject().getFolder(webrootName).getLocation()
-						.toString();
-			}
-		} catch (NullPointerException e) {
-			return uri;
-		}
-		if (uri.startsWith(IFileFolderConstants.PATH_SEPARATOR))
-		{
-			return webroot + uri;
-		}
-		if (jsp != null) {
-			IContainer con = jsp.getParent();
-			if (con != null) {
-				IPath path = con.getLocation();
-				if (path != null) {
-					String aPath = path.toString() + File.separator + uri;
-					aPath = aPath.replace('/', File.separatorChar);
-					aPath = aPath.replace('\\', File.separatorChar);
-					if (aPath.endsWith(File.separator)) {
-						aPath += IFileFolderConstants.PATH_SEPARATOR;
-					}
-					File file = new File(aPath);
-					if (file.exists() && file.isFile()) {
-						return file.getAbsolutePath();
-					}
-                    return uri;
-				}
-			}
-		}
-		return uri;
-	}
-
-	/**
-	 * Returns the active workbench window.
-	 * 
-	 * @return the active workbench window. this can be null but I've never seen
-	 *         it.
-	 */
-	private static IWorkbenchWindow getActiveWorkbenchWindow() {
-		if (PlatformUI.getWorkbench() == null) {
-			return null;
-		}
-        return PlatformUI.getWorkbench().getActiveWorkbenchWindow();
-	}
-
-	/**
-	 * Returns the active workbench page. Note that the active page may not be
-	 * the one that the user perceives as active in some situations so this
-	 * method of obtaining the activate page should only be used if no other
-	 * method is available.
-	 * 
-	 * @return the active workbench page
-	 */
-	private static IWorkbenchPage getActivePage() {
-		IWorkbenchWindow window = getActiveWorkbenchWindow();
-		if (window == null) {
-			return null;
-		}
-		return window.getActivePage();
-	}
-	/**
-	 * @param javaProject
-	 * @param parent
-	 * @return the IPath for a a classpath object (?)
-	 */
-	public static IPath getPathOnClasspath(IJavaProject javaProject,
-			Object parent) {
-		IPath result = null;
-		if (javaProject == null || parent == null) {
-			return new Path(""); //$NON-NLS-1$
-		}
-		IClasspathEntry[] entries = javaProject.readRawClasspath();
-		IPath classPath = null;
-		if (parent instanceof IResource) {
-			if (((javaProject != null) && !javaProject
-					.isOnClasspath((IResource) parent))) {
-				return new Path(""); //$NON-NLS-1$
-			}
-			if (parent instanceof IFile) {
-				IPath elementPath = ((IFile) parent).getFullPath();
-				if (((IFile) parent).getFileExtension().equalsIgnoreCase(
-						IFileFolderConstants.EXT_PROPERTIES)) {
-					int machings = 0;
-					try {
-						for (int i = 0; i < entries.length; i++) {
-							// Determine whether on this classentry's path
-							int n = entries[i].getPath().matchingFirstSegments(
-									elementPath);
-							if (n > machings) {
-								// Get package name
-								machings = n;
-								classPath = elementPath.removeFirstSegments(
-										machings).removeLastSegments(1);
-							}
-						}
-
-						// Not on the classpath?
-						if (classPath == null) {
-							return null;
-						} else if (classPath.segmentCount() > 0) {
-							IJavaElement element = javaProject
-									.findElement(classPath);
-							if (element != null) {
-								IPath path = element.getPath();
-								if (path != null) {
-									IPath path1 = path
-											.removeFirstSegments(machings);
-
-									String fileName = ((IFile) parent)
-											.getName();
-									if (fileName != null) {
-										result = path1.append(fileName);
-									}
-								}
-							}
-
-						} else {
-							result = ((IFile) parent).getFullPath()
-									.removeFirstSegments(machings);
-						}
-					} catch (Exception e) {
-						return null;
-					}
-				}
-			}
-		} else if (parent instanceof IJarEntryResource) {
-			IPath elementPath = ((IJarEntryResource) parent).getFullPath();
-			if (elementPath.getFileExtension().equalsIgnoreCase(
-					IFileFolderConstants.EXT_PROPERTIES)) {
-				result = elementPath;
-			}
-		}
-		if (result != null) {
-			return result;
-		}
-		return new Path(""); //$NON-NLS-1$
-	}
-	
-	private PathUtil()
-	{
-		// utility class, no instantiation
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/PixelConverter.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/PixelConverter.java
deleted file mode 100644
index 48d5b37..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/PixelConverter.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2000, 2007 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *     Oracle -- copied into common ui codebase for JSF use
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.utils;
-
-import org.eclipse.swt.graphics.Font;
-import org.eclipse.swt.graphics.FontMetrics;
-import org.eclipse.swt.graphics.GC;
-import org.eclipse.swt.widgets.Control;
-
-import org.eclipse.jface.dialogs.Dialog;
-
-/**
- * @author cbateman
- *
- */
-public class PixelConverter {
-    
-    private final FontMetrics fFontMetrics;
-    
-    /**
-     * @param control
-     */
-    public PixelConverter(Control control) {
-        this(control.getFont());
-    }
-    
-    /**
-     * @param font
-     */
-    public PixelConverter(Font font) {
-        GC gc = new GC(font.getDevice());
-        gc.setFont(font);
-        fFontMetrics= gc.getFontMetrics();
-        gc.dispose();
-    }
-    
-
-    /**
-     * @param chars
-     * @return the convert height in  pixels
-     */
-    public int convertHeightInCharsToPixels(int chars) {
-        return Dialog.convertHeightInCharsToPixels(fFontMetrics, chars);
-    }
-
-    /**
-     * @param dlus
-     * @return the pixel
-     */ 
-    public int convertHorizontalDLUsToPixels(int dlus) {
-        return Dialog.convertHorizontalDLUsToPixels(fFontMetrics, dlus);
-    }
-
-    /**
-     * @param dlus
-     * @return the vertical pixels
-     */
-    public int convertVerticalDLUsToPixels(int dlus) {
-        return Dialog.convertVerticalDLUsToPixels(fFontMetrics, dlus);
-    }
-    
-
-    /**
-     * @param chars
-     * @return the pixel value
-     */
-    public int convertWidthInCharsToPixels(int chars) {
-        return Dialog.convertWidthInCharsToPixels(fFontMetrics, chars);
-    }   
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/PluginImageHelper.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/PluginImageHelper.java
deleted file mode 100644
index 8ebcd03..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/PluginImageHelper.java
+++ /dev/null
@@ -1,213 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.utils;
-
-import java.util.HashMap;
-
-import org.eclipse.jface.resource.ImageDescriptor;
-import org.eclipse.jface.resource.ImageRegistry;
-import org.eclipse.jface.resource.JFaceResources;
-import org.eclipse.swt.graphics.Image;
-import org.eclipse.ui.plugin.AbstractUIPlugin;
-
-/**
- * @author mengbo
- */
-public class PluginImageHelper {
-	private static PluginImageHelper _instance = null;
-
-	/**
-	 * Gets the instance.
-	 * 
-	 * @return Returns a TaglibPluginImageHelper
-	 */
-	public synchronized static PluginImageHelper getInstance() {
-		if (_instance == null) {
-			_instance = new PluginImageHelper();
-		}
-		return _instance;
-	}
-
-	// save a descriptor for each image
-	private HashMap _imageDescRegistry = null;
-
-	private final String PLUGIN_SEPARATOR = "^"; //$NON-NLS-1$
-
-	/**
-	 * Creates an image from the given resource and adds the image to the image
-	 * registry.
-	 * 
-	 * @param resource
-	 * @param pluginId
-	 * @return Image
-	 */
-	private Image createImage(String resource, String pluginId) {
-		ImageDescriptor desc = getImageDescriptor(resource, pluginId);
-		Image image = null;
-
-		if (desc != null) {
-			image = desc.createImage();
-
-			// dont add the missing image descriptor image to the image
-			// registry
-			if (!desc.equals(ImageDescriptor.getMissingImageDescriptor())) {
-				String thePluginId = pluginId;
-				if (thePluginId == null) {
-					return null;
-				}
-				String key = thePluginId + PLUGIN_SEPARATOR + resource;
-				getImageRegistry().put(key, image);
-			}
-		}
-		return image;
-	}
-
-	/**
-	 * Creates an image descriptor from the given imageFilePath in the given
-	 * pluginId and adds the image descriptor to the image descriptor registry.
-	 * If an image descriptor could not be created, the default "missing" image
-	 * descriptor is returned but not added to the image descriptor registry.
-	 * 
-	 * @param imageFilePath
-	 * @param pluginId
-	 *            if null, look in this plugin
-	 * @return ImageDescriptor image descriptor for imageFilePath or default
-	 *         "missing" image descriptor if resource could not be found
-	 */
-	private ImageDescriptor createImageDescriptor(String imageFilePath,
-			String pluginId) {
-		String thePluginId = pluginId;
-		if (thePluginId == null) {
-			return null;
-		}
-
-		ImageDescriptor imageDescriptor = AbstractUIPlugin
-				.imageDescriptorFromPlugin(thePluginId, imageFilePath);
-		if (imageDescriptor != null) {
-			String key = thePluginId + PLUGIN_SEPARATOR + imageFilePath;
-			getImageDescriptorRegistry().put(key, imageDescriptor);
-		} else {
-			imageDescriptor = ImageDescriptor.getMissingImageDescriptor();
-		}
-
-		return imageDescriptor;
-	}
-
-	/**
-	 * Retrieves the image associated with resource from the image registry. If
-	 * the image cannot be retrieved, attempt to find and load the image at the
-	 * location specified in resource.
-	 * 
-	 * @param resource
-	 *            the image to retrieve
-	 * @return Image the image associated with resource or null if one could not
-	 *         be found
-	 */
-	public Image getImage(String resource) {
-		return getImage(resource, null);
-	}
-
-	/**
-	 * Retrieves the image associated with resource from the image registry. If
-	 * the image cannot be retrieved, attempt to find and load the image at the
-	 * location specified in resource.
-	 * 
-	 * @param resource
-	 *            the image to retrieve
-	 * @param pluginId
-	 * @return Image the image associated with resource or null if one could not
-	 *         be found
-	 */
-	public Image getImage(String resource, String pluginId) {
-		String thePluginId = pluginId;
-		if (thePluginId == null) {
-			return null;
-		}
-
-		String key = thePluginId + PLUGIN_SEPARATOR + resource;
-
-		Image image = getImageRegistry().get(key);
-		if (image == null) {
-			// create an image
-			image = createImage(resource, pluginId);
-		}
-		return image;
-	}
-
-	/**
-	 * Retrieves the image descriptor associated with resource from the image
-	 * descriptor registry. If the image descriptor cannot be retrieved, attempt
-	 * to find and load the image descriptor at the location specified in
-	 * resource.
-	 * 
-	 * @param resource
-	 *            the image descriptor to retrieve
-	 * @return ImageDescriptor the image descriptor assocated with resource or
-	 *         the default "missing" image descriptor if one could not be found
-	 */
-	public ImageDescriptor getImageDescriptor(String resource) {
-		return getImageDescriptor(resource, null);
-	}
-
-	/**
-	 * Retrieves the image descriptor associated with resource in pluginId from
-	 * the image descriptor registry. If the image descriptor cannot be
-	 * retrieved, attempt to find and load the image descriptor at the location
-	 * specified in resource in pluginId.
-	 * 
-	 * @param resource
-	 *            the image descriptor to retrieve
-	 * @param pluginId
-	 *            the plugin the resource is located. if null, use look in this
-	 *            plugin
-	 * @return ImageDescriptor the image descriptor assocated with resource or
-	 *         the default "missing" image descriptor if one could not be found
-	 */
-	public ImageDescriptor getImageDescriptor(String resource, String pluginId) {
-		ImageDescriptor imageDescriptor = null;
-		String thePluginId = pluginId;
-		if (thePluginId == null) {
-			return null;
-		}
-
-		String key = thePluginId + PLUGIN_SEPARATOR + resource;
-		Object o = getImageDescriptorRegistry().get(key);
-		if (o == null) {
-			// create a descriptor
-			imageDescriptor = createImageDescriptor(resource, pluginId);
-		} else {
-			imageDescriptor = (ImageDescriptor) o;
-		}
-		return imageDescriptor;
-	}
-
-	/**
-	 * Returns the image descriptor registry for this plugin.
-	 * 
-	 * @return HashMap - image descriptor registry for this plugin
-	 */
-	private HashMap getImageDescriptorRegistry() {
-		if (_imageDescRegistry == null) {
-			_imageDescRegistry = new HashMap();
-		}
-		return _imageDescRegistry;
-	}
-
-	/**
-	 * Returns the image registry for this plugin.
-	 * 
-	 * @return ImageRegistry - image registry for this plugin
-	 */
-	private ImageRegistry getImageRegistry() {
-		return JFaceResources.getImageRegistry();
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/PropertyUtils.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/PropertyUtils.java
deleted file mode 100644
index 47bded0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/PropertyUtils.java
+++ /dev/null
@@ -1,789 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.utils;
-
-import java.awt.Component;
-import java.awt.Dimension;
-import java.awt.Point;
-import java.awt.Rectangle;
-import java.awt.Toolkit;
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.MissingResourceException;
-import java.util.Properties;
-import java.util.ResourceBundle;
-import java.util.StringTokenizer;
-
-import org.eclipse.jst.jsf.common.ui.JSFUICommonPlugin;
-
-/**
- * The main purpose of this class is to give better access methods for property
- * and resource bundle access.
- * 
- * @author mengbo
- */
-public final class PropertyUtils {
-
-	private static final String ENCODED_CHAR_PERCENT = "%25"; //$NON-NLS-1$
-	private static final String ENCODED_CHAR_CARRIAGE_RETURN = "%0d"; //$NON-NLS-1$
-	private static final String ENCODED_CHAR_TAB = "%09"; //$NON-NLS-1$
-	private static final String ENCODED_CHAR_NEWLINE = "%0a"; //$NON-NLS-1$
-	private static final String ENCODED_CHAR_SPACE = "%20"; //$NON-NLS-1$
-	private static final String ENCODED_CHAR_COLON = "%3a"; //$NON-NLS-1$
-	private static final String ENCODED_CHAR_EQUALS = "%3d"; //$NON-NLS-1$
-
-	
-	// WARNING: There can be NO static logging line here since the logger uses
-	// this class to figure out the preferences
-	// for the logging system. "Logging" an error here would be useless since
-	// you might be setting up the logging system
-	// via a call to PropertyUtils.getServerProperty() instead it uses
-	// "System.err.println".
-
-	// This is the name for the properties file.
-	// The prop-name will be prepended to this string....
-	private static final String NAME_PROPERTIES = ".props"; //$NON-NLS-1$
-
-	private static final String STR_BOUNDS_END = ".bounds"; // assumes the //$NON-NLS-1$
-
-	// window name or
-	// name list is
-	// prepended
-
-	// //////////////////////////////////////////////////////////////////////////
-	// Property get methods.
-	// //////////////////////////////////////////////////////////////////////////
-	/**
-	 * @param props
-	 * @param key
-	 * @param theDefault
-	 * @return the property
-	 */
-	public static String getProperty(Properties props, String key,
-			String theDefault) {
-		try {
-			String value = props.getProperty(key, theDefault);
-			if ((value != null) && (value.length() == 0)) {
-				value = null;
-			}
-			// check again for null, since some versions of the jdk ignore the
-			// default
-			// if an empty property exists.
-			if (value == null) {
-				value = theDefault;
-			}
-			return value;
-		} catch (Exception ee) {
-			return theDefault;
-		}
-	}
-
-	/**
-	 * @param props
-	 * @param key
-	 * @return the value for key in props, may return null
-	 */
-	public static String getProperty(Properties props, String key) {
-		try {
-			String value = props.getProperty(key);
-			if ((value != null) && (value.length() == 0)) {
-				value = null;
-			}
-			return value;
-		} catch (Exception ee) {
-			return null;
-		}
-	}
-
-	/**
-	 * @param props
-	 * @param key
-	 * @param defaultValue
-	 * @param minimumValue
-	 * @return the integer property value for key, or defaultValue
-	 * if none.  Enforces minimumValue in all cases
-	 */
-	public static int getPropertyValue(Properties props, String key,
-			int defaultValue, int minimumValue) {
-		int theValue = getPropertyValue(props, key, defaultValue);
-
-		if (theValue < minimumValue) {
-			theValue = minimumValue;
-		}
-		return theValue;
-	}
-
-	/**
-	 * @param props
-	 * @param key
-	 * @param defaultValue
-	 * @return the integer value for key in props or defaultValue if none
-	 */
-	public static int getPropertyValue(Properties props, String key,
-			int defaultValue) {
-		String stringValue = getProperty(props, key);
-		if (stringValue != null) {
-			try {
-				return Integer.parseInt(stringValue);
-			} catch (NumberFormatException ee)// NOPMD
-			{
-				// the property value maybe an invalid value, the editor should
-				// show these to user.
-			}
-		}
-		return defaultValue;
-	}
-
-	/**
-	 * @param props
-	 * @param key
-	 * @param defaultValue
-	 * @return the long value for key props or defaultValue if none
-	 */
-	public static long getPropertyLongValue(Properties props, String key,
-			long defaultValue) {
-		String stringValue = getProperty(props, key);
-		if (stringValue != null) {
-			try {
-				return Long.parseLong(stringValue);
-			} catch (NumberFormatException ee)// NOPMD
-			{
-				// the property value maybe an invalid value, the editor should
-				// show these to user.
-			}
-		}
-		return defaultValue;
-	}
-
-	/**
-	 * @param props
-	 * @param key
-	 * @param bDefault
-	 * @return true if props has a value for key
-	 */
-	public static boolean isProperty(Properties props, String key,
-			boolean bDefault) {
-		return getProperty(props, key, "" + bDefault).equals("" + true); //$NON-NLS-1$ //$NON-NLS-2$
-	}
-
-	/**
-	 * @param props
-	 * @param key
-	 * @return the string values in props for key tokenized from
-	 * a comma-separated string
-	 */
-	public static String[] getPropertyStrings(Properties props, String key) {
-		String tokenString = getProperty(props, key);
-
-		if (tokenString == null) {
-			return new String[0];
-		}
-        StringTokenizer tokenizer = new StringTokenizer(tokenString, ","); //$NON-NLS-1$
-        String[] pNames = new String[tokenizer.countTokens()];
-
-        for (int ii = 0; ii < pNames.length; ii++) {
-        	pNames[ii] = ((String) tokenizer.nextElement()).trim();
-        }
-        return pNames;
-	}
-
-	// //////////////////////////////////////////////////////////////////////////
-	// Resource bundle get methods.
-	// //////////////////////////////////////////////////////////////////////////
-	/**
-	 * @param bundle
-	 * @param key
-	 * @param theDefault
-	 * @return the string value from bundle for key or default if none
-	 */
-	public static String getResourceProperty(ResourceBundle bundle, String key,
-			String theDefault) {
-		try {
-			String value = bundle.getString(key);
-			if ((value == null) || (value.length() == 0)) {
-				value = theDefault;
-			}
-			return value;
-		} 
-		catch(NullPointerException npe)
-		{
-			return theDefault;
-		}
-		catch (MissingResourceException mre)
-		{
-			return theDefault;
-		}
-		catch (ClassCastException cce)
-		{
-			return theDefault;
-		}
-	}
-
-	/**
-	 * @param bundle
-	 * @param key
-	 * @return the value for key in bundle or null if none
-	 */
-	public static String getResourceProperty(ResourceBundle bundle, String key) {
-		try 
-		{
-			String value = bundle.getString(key);
-			if ((value != null) && (value.length() == 0)) 
-			{
-				value = null;
-			}
-				return value;
-		}
-		catch(NullPointerException npe)
-		{
-			return null;
-		}
-		catch (MissingResourceException mre)
-		{
-			return null;
-		}
-		catch (ClassCastException cce)
-		{
-			return null;
-		}
-	}
-
-	/**
-	 * @param bundle
-	 * @param key
-	 * @param defaultValue
-	 * @param minimumValue
-	 * @return the integer value for key in bundle or defaultValue if none
-	 * Enforces minimum value in all cases
-	 */
-	public static int getResourcePropertyValue(ResourceBundle bundle,
-			String key, int defaultValue, int minimumValue) {
-		int theValue = getResourcePropertyValue(bundle, key, defaultValue);
-
-		if (theValue < minimumValue) {
-			theValue = minimumValue;
-		}
-		return theValue;
-	}
-
-	/**
-	 * @param bundle
-	 * @param key
-	 * @param defaultValue
-	 * @return the integer value for key in bundle or defaultValue if  none
-	 */
-	public static int getResourcePropertyValue(ResourceBundle bundle,
-			String key, int defaultValue) {
-		String stringValue = getResourceProperty(bundle, key);
-		if (stringValue != null) {
-			try {
-				return Integer.parseInt(stringValue);
-			} catch (NumberFormatException ee)// NOPMD
-			{
-				// the property value maybe an invalid value, the editor should
-				// show these to user.
-			}
-		}
-		return defaultValue;
-	}
-
-	/**
-	 * @param bundle
-	 * @param key
-	 * @param defaultValue
-	 * @return the long value for key in bundle or default value if none
-	 */
-	public static long getResourcePropertyLongValue(ResourceBundle bundle,
-			String key, long defaultValue) {
-		String stringValue = getResourceProperty(bundle, key);
-		if (stringValue != null) {
-			try {
-				return Long.parseLong(stringValue);
-			} catch (NumberFormatException ee)// NOPMD
-			{
-				// the property value maybe an invalid value, the editor should
-				// show these to user.
-			}
-		}
-		return defaultValue;
-	}
-
-	/**
-	 * @param bundle
-	 * @param key
-	 * @param bDefault
-	 * @return true if bundle has a value for key
-	 */
-	public static boolean isResourceProperty(ResourceBundle bundle, String key,
-			boolean bDefault) {
-		return getResourceProperty(bundle, key, "" + bDefault) //$NON-NLS-1$
-				.equals("" + true); //$NON-NLS-1$
-	}
-
-	// ///////////////////////////////////////////////////////////////////////
-	// Property misc routines
-	// ///////////////////////////////////////////////////////////////////////
-	/**
-	 * @param theName
-	 * @return the encoded name
-	 */
-	public static String encodeName(String theName) {
-		int theSize = theName.length();
-		StringBuffer encoded = new StringBuffer(theSize);
-		char ch;
-
-		for (int ii = 0; ii < theSize; ii++) {
-			ch = theName.charAt(ii);
-			switch (ch) {
-			// these are the set of illegal characters in a Property name
-			case '=': // %3d
-				encoded.append(ENCODED_CHAR_EQUALS);
-				break;
-			case ':': // %3a
-				encoded.append(ENCODED_CHAR_COLON);
-				break;
-			case ' ': // %20
-				encoded.append(ENCODED_CHAR_SPACE);
-				break;
-			case '\n': // %0a
-				encoded.append(ENCODED_CHAR_NEWLINE);
-				break;
-			case '\t': // %09
-				encoded.append(ENCODED_CHAR_TAB);
-				break;
-			case '\r': // %0d
-				encoded.append(ENCODED_CHAR_CARRIAGE_RETURN);
-				break;
-			case '%': // %25
-				// added because its our encoding flag
-				encoded.append(ENCODED_CHAR_PERCENT);
-				break;
-			default:
-				encoded.append(ch);
-				break;
-			}
-		}
-
-		return encoded.toString();
-	}
-
-	/**
-	 * @param theName
-	 * @return the decoded name
-	 */
-	public static String decodeName(String theName) {
-		int theSize = theName.length();
-		int kk;
-		StringBuffer decoded = new StringBuffer(theSize);
-		char ch;
-
-		for (int ii = 0; ii < theSize; ii++) {
-			ch = theName.charAt(ii);
-			if (ch == '%') {
-				ch = theName.charAt(++ii);
-				kk = Character.digit(ch, 16);
-				kk *= 16;
-				ch = theName.charAt(++ii);
-				kk += Character.digit(ch, 16);
-				decoded.append((char) kk);
-			} else {
-				decoded.append(ch);
-			}
-		}
-
-		return decoded.toString();
-	}
-
-	/**
-	 * @param propName
-	 * @return the properties
-	 * @throws IOException
-	 * @throws FileNotFoundException
-	 */
-	public static Properties openProperties(String propName)
-			throws IOException, FileNotFoundException {
-		return openProperties(propName, null, true);
-	}
-
-	/**
-	 * @param propName
-	 * @param propDefaults
-	 * @return the properties
-	 * @throws IOException
-	 * @throws FileNotFoundException
-	 */
-	public static Properties openProperties(String propName,
-			Properties propDefaults) throws IOException, FileNotFoundException {
-		return openProperties(propName, propDefaults, true);
-	}
-
-	/**
-	 * @param propName
-	 * @param propDefaults
-	 * @param bCreatePropertiesPathname
-	 * @return the properties
-	 * @throws IOException
-	 * @throws FileNotFoundException
-	 */
-	public static Properties openProperties(String propName,
-			Properties propDefaults, boolean bCreatePropertiesPathname)
-			throws IOException, FileNotFoundException {
-		Properties theProperties = new Properties(propDefaults);
-
-		try {
-			String propertiesFilename = bCreatePropertiesPathname ? getPropertiesPathname(propName)
-					: propName;
-			InputStream theStream = new FileInputStream(propertiesFilename);
-			theProperties.load(theStream);
-			theStream.close();
-		} catch (FileNotFoundException ee) {
-			if (propDefaults == null) {
-				throw ee;
-			}
-		} catch (IOException ee) {
-			if (propDefaults == null) {
-				throw ee;
-			}
-		}
-
-		return theProperties;
-	}
-
-	/**
-	 * Combines two properties objects, with the second one as the default
-	 * properties
-	 * 
-	 * @param localProperties
-	 * @param defaultProperties
-	 * @return the combined properties
-	 * @throws IOException
-	 */
-	public static Properties combineProperties(Properties localProperties,
-			Properties defaultProperties) throws IOException {
-		Properties theNewProperties = new Properties();
-
-		ByteArrayOutputStream os = new ByteArrayOutputStream();
-		defaultProperties.store(os, ""); //$NON-NLS-1$
-		localProperties.store(os, ""); //$NON-NLS-1$
-		byte[] theData = os.toByteArray();
-		ByteArrayInputStream is = new ByteArrayInputStream(theData);
-		theNewProperties.load(is);
-
-		return theNewProperties;
-	}
-
-	/**
-	 * @param theFilename
-	 * @return the encoded file name
-	 */ 
-	public static String encodeFilename(String theFilename) {
-		// make theFilename legal on the local system....
-		String theSeparator = System.getProperty("file.separator"); //$NON-NLS-1$
-		// replace all occurrances of the file separator with a ' '
-		for (int ii = 0; ii < theSeparator.length(); ii++) {
-			char theChar = theSeparator.charAt(ii);
-			theFilename = theFilename.replace(theChar, ' ');
-		}
-
-		return theFilename;
-	}
-
-	/**
-	 * @param baseName
-	 * @return the properties path
-	 */
-	public static String getPropertiesPathname(String baseName) {
-		if (baseName.endsWith(NAME_PROPERTIES)) {
-			return System.getProperty("user.dir") //$NON-NLS-1$
-					+ System.getProperty("file.separator") //$NON-NLS-1$
-					+ encodeFilename(baseName);
-		}
-        return System.getProperty("user.dir") //$NON-NLS-1$
-        		+ System.getProperty("file.separator") //$NON-NLS-1$
-        		+ encodeFilename(baseName) + NAME_PROPERTIES;
-	}
-
-	// /////////////////////////////////////////////////////////////////////////
-	// These are generic routines that are used to get/set/save window bounds
-
-	private static final int INSET = 40;
-
-	/**
-	 * Set the initial bounds (size & location) of a component. This will get
-	 * the location from the preferences file based on the values of the "names"
-	 * parameter. These values will be encoded to make a legal properties name,
-	 * joined togther with ".", and the value STR_BOUNDS_END will be appended.
-	 * The resulting name will be used to obtain the intial bounds value from
-	 * the properties file, which will be decoded and the specified component
-	 * will then be set to that value.
-	 * @param props 
-	 * @param theComponent 
-	 * @param names 
-	 * @param defaultValue 
-	 */
-	public static void setComponentBounds(Properties props,
-			Component theComponent, String names[], String defaultValue) {
-		setComponentBounds(props, theComponent, names, defaultValue, false);
-	}
-
-	/**
-	 * @param props
-	 * @param theComponent
-	 * @param names
-	 * @param defaultValue
-	 * @param bEnsureDesktopVisibility
-	 */
-	public static void setComponentBounds(Properties props,
-			Component theComponent, String names[], String defaultValue,
-			boolean bEnsureDesktopVisibility) {
-		String tmpString = getComponentPropertyName(names, STR_BOUNDS_END);
-		setComponentBounds(props, theComponent, tmpString, defaultValue,
-				bEnsureDesktopVisibility);
-	}
-
-	/**
-	 * @param props
-	 * @param theComponent
-	 * @param thePropertyName
-	 * @param defaultValue
-	 */
-	public static void setComponentBounds(Properties props,
-			Component theComponent, String thePropertyName, String defaultValue) {
-		setComponentBounds(props, theComponent, thePropertyName, defaultValue,
-				false);
-	}
-
-	/**
-	 * @param props
-	 * @param theComponent
-	 * @param thePropertyName
-	 * @param defaultValue
-	 * @param bEnsureDesktopVisibility
-	 */
-	public static void setComponentBounds(Properties props,
-			Component theComponent, String thePropertyName,
-			String defaultValue, boolean bEnsureDesktopVisibility) {
-		String tmpString = props.getProperty(thePropertyName, defaultValue);
-		Rectangle theValue = decodeBounds(tmpString);
-		theComponent.setBounds(theValue);
-		if (bEnsureDesktopVisibility) {
-			// make sure that this component is visible on the desktop...
-			// verify that this window is visible...
-			Point theLoc = theComponent.getLocation();
-			// get width/height of desktop....
-			Dimension portSize = new Dimension(Toolkit.getDefaultToolkit()
-					.getScreenSize());
-			if (theLoc.x > portSize.width) // move it to top
-				theLoc.x = INSET;
-			if (theLoc.y > portSize.height) // move it to left
-				theLoc.y = INSET;
-			theComponent.setLocation(theLoc);
-		}
-	}
-
-	/**
-	 * @param props
-	 * @param theComponent
-	 * @param names
-	 */
-	public static void saveComponentBounds(Properties props,
-			Component theComponent, String names[]) {
-		String tmpString = getComponentPropertyName(names, STR_BOUNDS_END);
-		saveComponentBounds(props, theComponent, tmpString);
-	}
-
-	/**
-	 * @param props
-	 * @param theComponent
-	 * @param thePropertyName
-	 */
-	public static void saveComponentBounds(Properties props,
-			Component theComponent, String thePropertyName) {
-		Rectangle theBounds = theComponent.getBounds();
-		String theValue = encodeBounds(theBounds);
-		props.put(thePropertyName, theValue);
-	}
-
-	/**
-	 * @param names
-	 * @param subsystemName
-	 * @return the component property name or ""
-	 */
-	public static String getComponentPropertyName(String names[],
-			String subsystemName) {
-		String tmpString = ""; //$NON-NLS-1$
-
-		for (int ii = 0; ii < names.length; ii++) {
-			tmpString = tmpString + (ii > 0 ? "." : "") //$NON-NLS-1$ //$NON-NLS-2$
-					+ PropertyUtils.encodeName(names[ii]);
-		}
-		if (subsystemName.startsWith(".") == false) //$NON-NLS-1$
-			tmpString += "."; //$NON-NLS-1$
-		tmpString = tmpString + subsystemName;
-		return tmpString;
-	}
-
-	/**
-	 * Decode the comma separated values stored in sBounds. This method is
-	 * normally called to decode the location/size of a component which has been
-	 * saved into a Properties object. See encodeBounds(); Order of items in the
-	 * string is (x, y, w, h)
-	 * @param sBounds 
-	 * @return the rectangle
-	 */
-	public static Rectangle decodeBounds(String sBounds) {
-		int index;
-		int ii;
-		int theValue[] = new int[4];
-		String tmpString;
-		String restString = sBounds;
-
-		for (ii = 0; ii < 4; ii++) {
-			theValue[ii] = 0;
-		}
-		try {
-			for (ii = 0; ii < 4; ii++) {
-				index = restString.indexOf(","); //$NON-NLS-1$
-				if (index > 0) {
-					tmpString = restString.substring(0, index);
-					restString = restString.substring(index + 1);
-				} else {
-					tmpString = restString; // should only happen on the last
-					// one....
-					restString = null; // will cause an exception if not last
-					// one...
-				}
-				theValue[ii] = Integer.valueOf(tmpString).intValue();
-			}
-		} catch (Exception ee)// NOPMD
-		{
-			// the property value maybe an invalid value, the editor should show
-			// these to user.
-		}
-
-		return new Rectangle(theValue[0], theValue[1], theValue[2], theValue[3]);
-	}
-
-	/**
-	 * * Encode the bounds of a component into a comma separated list * that is
-	 * appropriate for storing in a Properties object. * See decodeBounds();
-	 * @param rBounds 
-	 * @return the encoded bounds
-	 */
-	public static String encodeBounds(Rectangle rBounds) {
-		return "" + rBounds.x + "," + rBounds.y + "," + rBounds.width + "," //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-				+ rBounds.height;
-	}
-
-	/**
-	 * Methods for creating Properties objects from strings.
-	 * 
-	 * Then "Encoded" versions are used on values that are stored into a
-	 * properties file (think of them as sub-properties). They do the encoding
-	 * necessary to turn a properties object into a string that has legal
-	 * "value" syntax (they actually do more than they need to, but its all
-	 * non-destructive).
-	 * @param thePropertyString 
-	 * @return the properties from the string
-	 * @throws IOException 
-	 */
-	public static Properties getPropertiesFromString(String thePropertyString)
-			throws IOException {
-		if (thePropertyString == null)
-			return null;
-		ByteArrayInputStream in = new ByteArrayInputStream(thePropertyString
-				.getBytes());
-
-		Properties props = new Properties();
-		props.load(in); // throws IOException
-		in = null;
-		return props;
-	}
-
-	/**
-	 * @param theEncodedPropertyString
-	 * @return the properties
-	 * @throws IOException
-	 */
-	public static Properties getPropertiesFromEncodedString(
-			String theEncodedPropertyString) throws IOException {
-		if (theEncodedPropertyString == null)
-			return null;
-		return (getPropertiesFromString(decodeName(theEncodedPropertyString)));
-	}
-
-	/**
-	 * @param theEncodedPropertyString
-	 * @return the properties
-	 */
-	public static Properties encodedStringToProperties(
-			String theEncodedPropertyString) {
-		try {
-			return getPropertiesFromEncodedString(theEncodedPropertyString);
-		} catch (IOException ee) {
-			return null;
-		}
-	}
-
-	/**
-	 * @param props
-	 * @param comment
-	 * @return the string
-	 * @throws IOException
-	 */
-	public static String savePropertiesToString(Properties props, String comment)
-			throws IOException {
-		if (props == null)
-			return null;
-		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		props.store(out, comment);
-		String tmpString = out.toString();
-		out = null;
-		return tmpString;
-	}
-
-	/**
-	 * @param props
-	 * @param comment
-	 * @return the encoded string
-	 * @throws IOException
-	 */
-	public static String savePropertiesToEncodedString(Properties props,
-			String comment) throws IOException {
-		if (props == null)
-			return null;
-		return encodeName(savePropertiesToString(props, comment));
-	}
-
-	/**
-	 * @param props
-	 * @return the encoded string
-	 */
-	public static String propertiesToEncodedString(Properties props) {
-		try {
-			return savePropertiesToEncodedString(props, ""); //$NON-NLS-1$
-		} catch (IOException ee)// NOPMD
-		{
-            JSFUICommonPlugin.getLogger(PropertyUtils.class).error("saving properties", ee); //$NON-NLS-1$
-		}
-		return null;
-	}
-	
-	private PropertyUtils()
-	{
-		// no instantiation
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/ResourceUtils.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/ResourceUtils.java
deleted file mode 100644
index e35ee83..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/ResourceUtils.java
+++ /dev/null
@@ -1,286 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.utils;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.text.MessageFormat;
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
-
-import org.eclipse.jst.jsf.common.ui.JSFUICommonPlugin;
-import org.eclipse.jst.jsf.common.ui.internal.logging.Logger;
-
-/**
- * Give easy access to a resource bundle.
- * 
- * @author mengbo
- */
-public abstract class ResourceUtils {
-	private static final String LOG_RESOURCE_UTILS_MSG_KEY = "log.ResourceUtils"; //$NON-NLS-1$
-	private static Logger _log = JSFUICommonPlugin.getLogger(ResourceUtils.class);
-	/**
-	 * the resource bundle accessible by all children
-	 */
-	protected ResourceBundle _resources;
-
-	/**
-	 * Empty Constructor.
-	 */
-	protected ResourceUtils() {
-        // restrict instantiation
-	}
-
-	/**
-	 * Easy way to set the bundle and get a fatal log messages and an alert if
-	 * the resource bundle is not found.
-	 * 
-	 * @param resource
-	 * @param bundleLocation
-	 */
-	protected void setBundle(ResourceBundle resource, String bundleLocation) {
-		_resources = resource;
-		if (_resources == null) {
-			// log.ResourceUtils=Missing Resource Bundle "{0}".
-			_log.error(LOG_RESOURCE_UTILS_MSG_KEY, bundleLocation);
-			// pluginName=Web Application Development Common
-			JSFUICommonPlugin.getAlerts().error("pluginName", LOG_RESOURCE_UTILS_MSG_KEY, //$NON-NLS-1$
-					bundleLocation);
-		}
-	}
-
-	/**
-	 * Get the property defined in the resource bundle for the given key. This
-	 * property should be an integer. If none is defined
-	 * (MissingResourceException), return the default.
-	 * 
-	 * @param key
-	 *            the key in the resource bundle.
-	 * @param defaultValue
-	 *            default int to return if no value is found for the key.
-	 * @return the integer value for key or defaultValue if none
-	 */
-	public int getValue(String key, int defaultValue) {
-		String stringValue = getString(key);
-		if (stringValue != null) {
-			try {
-				return Integer.parseInt(stringValue);
-			} catch (NumberFormatException ee)// NOPMD
-			{
-				// the property value maybe an invalid value, the editor should
-				// show these to user.
-			}
-		}
-		return defaultValue;
-	}
-
-	/**
-	 * Get the property defined in the resource bundle for the given key. This
-	 * property should be an long. If none is defined
-	 * (MissingResourceException), return the default.
-	 * 
-	 * @param key
-	 *            the key in the resource bundle.
-	 * @param defaultValue
-	 *            default long to return if no value is found for the key.
-	 * @return the long value for key or defaultValue if none
-	 */
-	public long getValue(String key, long defaultValue) {
-		String stringValue = getString(key);
-		if (stringValue != null) {
-			try {
-				return Long.parseLong(stringValue);
-			} catch (NumberFormatException ee)// NOPMD
-			{
-				// the property value maybe an invalid value, the editor should
-				// show these to user.
-			}
-		}
-		return defaultValue;
-	}
-
-	/**
-	 * Get the property defined in the resource bundle for the given key. This
-	 * property should be boolean ("true" of "false"). If none is defined
-	 * (MissingResourceException), return the default.
-	 * 
-	 * @param key
-	 *            the key in the resource bundle.
-	 * @return true if there is a resource corresponding to key
-	 */
-	public boolean isResource(String key) {
-		return getString(key).equals("" + true); //$NON-NLS-1$
-	}
-
-	/**
-	 * Get the property defined in the resource bundle for the given key. If
-	 * none is defined (MissingResourceException), return null.
-	 * 
-	 * @param key
-	 *            the key in the resource bundle.
-	 * @return the string value for key or key if not found
-	 */
-	public String getString(String key) {
-		try {
-			return _resources.getString(key);
-		} catch (MissingResourceException ee) {
-			return key;
-		}
-	}
-
-	/**
-	 * Build a formated string from the resource bundle.
-	 * 
-	 * @param key
-	 *            the key into the resource bundle that has the formated string.
-	 * @param arg0
-	 *            the first argument.
-	 * @return the formated string with the argument inline.
-	 */
-	public String getString(String key, Object arg0) {
-		Object[] args = new Object[1];
-		args[0] = arg0;
-
-		MessageFormat formatter = new MessageFormat(getString(key));
-		return formatter.format(args);
-	}
-
-	/**
-	 * Build a formated string from the resource bundle.
-	 * 
-	 * @param key
-	 *            the key into the resource bundle that has the formated string.
-	 * @param arg0
-	 *            the first argument.
-	 * @param arg1
-	 *            the second argument.
-	 * @return the formated string with the argument inline.
-	 */
-	public String getString(String key, Object arg0, Object arg1) {
-		Object[] args = new Object[2];
-		args[0] = arg0;
-		args[1] = arg1;
-
-		MessageFormat formatter = new MessageFormat(getString(key));
-		return formatter.format(args);
-	}
-
-	/**
-	 * Build a formated string from the resource bundle.
-	 * 
-	 * @param key
-	 *            the key into the resource bundle that has the formated string.
-	 * @param arg0
-	 *            the first argument.
-	 * @param arg1
-	 *            the second argument.
-	 * @param arg2
-	 *            the third argument.
-	 * @return the formated string with the argument inline.
-	 */
-	public String getString(String key, Object arg0, Object arg1, Object arg2) {
-		Object[] args = new Object[3];
-		args[0] = arg0;
-		args[1] = arg1;
-		args[2] = arg2;
-
-		MessageFormat formatter = new MessageFormat(getString(key));
-		return formatter.format(args);
-	}
-
-	/**
-	 * Build a formated string from the resource bundle.
-	 * 
-	 * @param key
-	 *            the key into the resource bundle that has the formated string.
-	 * @param arg0
-	 *            the first argument.
-	 * @param arg1
-	 *            the second argument.
-	 * @param arg2
-	 *            the third argument.
-	 * @param arg3
-	 *            the forth argument.
-	 * @return the formated string with the argument inline.
-	 */
-	public String getString(String key, Object arg0, Object arg1, Object arg2,
-			Object arg3) {
-		Object[] args = new Object[4];
-		args[0] = arg0;
-		args[1] = arg1;
-		args[2] = arg2;
-		args[3] = arg3;
-
-		MessageFormat formatter = new MessageFormat(getString(key));
-		return formatter.format(args);
-	}
-
-	/**
-	 * Build a formated string from the resource bundle.
-	 * 
-	 * @param key
-	 *            the key into the resource bundle that has the formated string.
-	 * @param arg0
-	 *            the first argument.
-	 * @param arg1
-	 *            the second argument.
-	 * @param arg2
-	 *            the third argument.
-	 * @param arg3
-	 *            the forth argument.
-	 * @param arg4
-	 *            the forth argument.
-	 * @return the formated string with the argument inline.
-	 */
-	public String getString(String key, Object arg0, Object arg1, Object arg2,
-			Object arg3, Object arg4) {
-		Object[] args = new Object[5];
-		args[0] = arg0;
-		args[1] = arg1;
-		args[2] = arg2;
-		args[3] = arg3;
-		args[4] = arg4;
-
-		MessageFormat formatter = new MessageFormat(getString(key));
-		return formatter.format(args);
-	}
-
-	/**
-	 * Build a formated string from the resource bundle.
-	 * 
-	 * @param key
-	 *            the key into the resource bundle that has the formated string.
-	 * @param args
-	 *            an array of arguments
-	 * @return the formated string with the argument inline.
-	 */
-	public String getString(String key, Object[] args) {
-		MessageFormat formatter = new MessageFormat(getString(key));
-		return formatter.format(args);
-	}
-
-	/**
-	 * Use in the try-finally idiom for inputStream to ensure close
-	 * and suppress exceptions on close
-	 * @param inputStream
-	 */
-	public static void ensureClosed(InputStream inputStream) {
-		if (inputStream != null) {
-			try {
-				inputStream.close();
-			} catch (IOException e) {
-				// Ignore
-			}
-		}
-
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/StringUtil.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/StringUtil.java
deleted file mode 100644
index e914b60..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/StringUtil.java
+++ /dev/null
@@ -1,157 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.utils;
-
-import java.util.regex.Pattern;
-
-/**
- * This is tool class for String processing.
- * 
- * @author mengbo
- */
-public class StringUtil {
-    
-    // pattern to find all end-of-paragraph and end-of-line html tags
-    // so they can be converted to newlines
-    final private static Pattern htmlToNewline = Pattern.compile("</p>|<br>"); //$NON-NLS-1$
-    
-    // pattern to strip all <x> and </x> HTML tags
-    final private static Pattern removeHTMLTags = Pattern.compile("<[/?\\w\\s=\"\\.\\#]+>"); //$NON-NLS-1$
-    
-    // pattern to find all runs of spaces longer than one
-    final private static Pattern trimInteriorWhitespace = Pattern.compile("[ ]+"); //$NON-NLS-1$
-    
-	/**
-	 * Split a java variable name into words For example, "_aJavaVariable" will
-	 * split to "A Java Variable", "_aWTPPackageImplementation" will be "A WTP
-	 * Package Implementation"
-	 * 
-	 * @param variable
-	 * @return String
-	 */
-	public static String splitVariable(String variable) {
-		StringBuffer output = new StringBuffer(""); //$NON-NLS-1$
-		boolean isCapitalLeading = false;
-		boolean isLastSpace = false;
-
-		for (int i = 0, n = variable.length(); i < n; i++) {
-			char letter = variable.charAt(i);
-
-			if (letter == '_' || letter == '$') {
-				output.append(" "); //$NON-NLS-1$
-				isCapitalLeading = false;
-				isLastSpace = true;
-				continue;
-			}
-
-			if (Character.isLowerCase(letter)) {
-				int nextIndex = i + 1;
-				if (nextIndex < n) {
-					char nextLetter = variable.charAt(nextIndex);
-					if (Character.isUpperCase(nextLetter)) {
-						if (isCapitalLeading) {
-							output.append(letter);
-							isLastSpace = false;
-						} else {
-							output.append(Character.toUpperCase(letter));
-							isLastSpace = false;
-						}
-						if (!isLastSpace) {
-							output.append(' ');
-							isLastSpace = true;
-						}
-						isCapitalLeading = false;
-						continue;
-					}
-				}
-			}
-			if (Character.isUpperCase(letter)) {
-				int nextIndex = i + 1;
-				if (nextIndex < n) {
-					char nextLetter = variable.charAt(nextIndex);
-					if (Character.isLowerCase(nextLetter)) {
-						if (!isLastSpace) {
-							output.append(' ');
-							isLastSpace = true;
-						}
-						output.append(letter);
-						isCapitalLeading = true;
-						isLastSpace = false;
-						continue;
-					}
-				}
-			}
-			if (isCapitalLeading) {
-				output.append(letter);
-				isLastSpace = false;
-			} else {
-				output.append(Character.toUpperCase(letter));
-				isCapitalLeading = true;
-				isLastSpace = false;
-			}
-		}
-
-		return output.toString().trim();
-	}
-
-	/**
-	 * @param str1
-	 * @param str2
-	 * @return boolean
-	 * 
-	 * Check if two strings match or not if str1=null and str2=null, it will
-	 * return true
-	 */
-	public static boolean isSameString(String str1, String str2) {
-		if (str1 == null) {
-			return str2 == null;
-		}
-        return str1.equals(str2);
-	}
-
-	/**
-	 * 
-	 * @param text
-	 * @return String Filter and convert a string, or normalize a string For
-	 *         example,
-	 *         <p>
-	 *         test
-	 *         </p>
-	 *         test1<a/> will be converted to: test\ntest1
-	 * 
-	 */
-	public static String filterConvertString(String text) {
-		if (text == null) {
-			return ""; //$NON-NLS-1$
-		}
-        
-		String result = htmlToNewline.matcher(text).replaceAll("\n");  //$NON-NLS-1$
-        result = removeHTMLTags.matcher(result).replaceAll(""); //$NON-NLS-1$
-        result = trimInteriorWhitespace.matcher(result).replaceAll(" "); //$NON-NLS-1$
-
-		return result;
-	}
-
-	/**
-	 * Determine whether a string is empty or not Example: null string -> return
-	 * true; Example: "" string -> return true; Otherwise, will return false;
-	 * @param str 
-	 * 
-	 * @return true if str is null or empty
-	 */
-	public static boolean isEmptyString(String str) {
-		if (str == null || str.length() == 0) {
-			return true;
-		}
-		return false;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/StyleCombo.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/StyleCombo.java
deleted file mode 100644
index 4eccfa6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/StyleCombo.java
+++ /dev/null
@@ -1,1877 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.utils;
-
-import java.util.Arrays;
-
-import org.eclipse.jface.resource.JFaceResources;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.accessibility.ACC;
-import org.eclipse.swt.accessibility.AccessibleAdapter;
-import org.eclipse.swt.accessibility.AccessibleControlAdapter;
-import org.eclipse.swt.accessibility.AccessibleControlEvent;
-import org.eclipse.swt.accessibility.AccessibleEvent;
-import org.eclipse.swt.accessibility.AccessibleTextAdapter;
-import org.eclipse.swt.accessibility.AccessibleTextEvent;
-import org.eclipse.swt.events.ModifyListener;
-import org.eclipse.swt.events.SelectionListener;
-import org.eclipse.swt.graphics.Color;
-import org.eclipse.swt.graphics.Font;
-import org.eclipse.swt.graphics.GC;
-import org.eclipse.swt.graphics.Point;
-import org.eclipse.swt.graphics.Rectangle;
-import org.eclipse.swt.widgets.Button;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Control;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.swt.widgets.Event;
-import org.eclipse.swt.widgets.Label;
-import org.eclipse.swt.widgets.Layout;
-import org.eclipse.swt.widgets.Listener;
-import org.eclipse.swt.widgets.Shell;
-import org.eclipse.swt.widgets.Table;
-import org.eclipse.swt.widgets.TableColumn;
-import org.eclipse.swt.widgets.TableItem;
-import org.eclipse.swt.widgets.Text;
-import org.eclipse.swt.widgets.TypedListener;
-
-/**
- * The CCombo class represents a selectable user interface object that combines
- * a text field and a list and issues notification when an item is selected from
- * the list.
- * <p>
- * Note that although this class is a subclass of <code>Composite</code>, it
- * does not make sense to add children to it, or set a layout on it.
- * </p>
- * <dl>
- * <dt><b>Styles:</b>
- * <dd>BORDER, READ_ONLY, FLAT</dd>
- * <dt><b>Events:</b>
- * <dd>Selection</dd>
- * </dl>
- */
-public final class StyleCombo extends Composite {
-
-	Text text;
-
-	Table table;
-
-	int visibleItemCount = 4;
-
-	Shell popup;
-
-	Button arrow;
-
-	boolean hasFocus;
-
-	Listener listener, filter;
-
-	Color foreground, background;
-
-	Font font;
-
-	String defaultValue;
-
-	/**
-	 * Constructs a new instance of this class given its parent and a style
-	 * value describing its behavior and appearance.
-	 * <p>
-	 * The style value is either one of the style constants defined in class
-	 * <code>SWT</code> which is applicable to instances of this class, or
-	 * must be built by <em>bitwise OR</em>'ing together (that is, using the
-	 * <code>int</code> "|" operator) two or more of those <code>SWT</code>
-	 * style constants. The class description lists the style constants that are
-	 * applicable to the class. Style bits are also inherited from superclasses.
-	 * </p>
-	 * 
-	 * @param parent
-	 *            a widget which will be the parent of the new instance (cannot
-	 *            be null)
-	 * @param style
-	 *            the style of widget to construct
-	 * 
-	 * @exception IllegalArgumentException
-	 *                <ul>
-	 *                <li>ERROR_NULL_ARGUMENT - if the parent is null</li>
-	 *                </ul>
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the parent</li>
-	 *                </ul>
-	 * 
-	 * @see SWT#BORDER
-	 * @see SWT#READ_ONLY
-	 * @see SWT#FLAT
-	 */
-	public StyleCombo(Composite parent, int style) {
-		super(parent, style = checkStyle(style));
-
-		listener = new Listener() {
-			public void handleEvent(Event event) {
-				if (popup == event.widget) {
-					popupEvent(event);
-					return;
-				}
-				if (text == event.widget) {
-					textEvent(event);
-					return;
-				}
-				if (table == event.widget) {
-					tableEvent(event);
-					return;
-				}
-				if (arrow == event.widget) {
-					arrowEvent(event);
-					return;
-				}
-				if (StyleCombo.this == event.widget) {
-					comboEvent(event);
-					return;
-				}
-				if (getShell() == event.widget) {
-					handleFocus(SWT.FocusOut);
-				}
-			}
-		};
-
-		filter = new Listener() {
-			public void handleEvent(Event event) {
-				Shell shell = ((Control) event.widget).getShell();
-				if (shell == StyleCombo.this.getShell()) {
-					handleFocus(SWT.FocusOut);
-				}
-			}
-		};
-
-		int[] comboEvents = { SWT.Dispose, SWT.Move, SWT.Resize };
-		for (int i = 0; i < comboEvents.length; i++)
-			this.addListener(comboEvents[i], listener);
-
-		createText(style);
-		createArrow(style);
-
-		createPopup(null, -1);
-		initAccessible();
-	}
-
-	/**
-	 * @param style
-	 */
-	private void createArrow(int style) {
-		int arrowStyle = SWT.ARROW | SWT.DOWN;
-		if ((style & SWT.FLAT) != 0) {
-			arrowStyle |= SWT.FLAT;
-		}
-		arrow = new Button(this, arrowStyle);
-		int[] arrowEvents = { SWT.Selection, SWT.FocusIn };
-		for (int i = 0; i < arrowEvents.length; i++) {
-			arrow.addListener(arrowEvents[i], listener);
-		}
-	}
-
-	/**
-	 * @param style
-	 */
-	private void createText(int style) {
-		int textStyle = SWT.SINGLE;
-		if ((style & SWT.READ_ONLY) != 0) {
-			textStyle |= SWT.READ_ONLY;
-		}
-		if ((style & SWT.FLAT) != 0) {
-			textStyle |= SWT.FLAT;
-		}
-		text = new Text(this, textStyle);
-		int[] textEvents = { SWT.KeyDown, SWT.KeyUp, SWT.Modify, SWT.MouseDown,
-				SWT.MouseUp, SWT.Traverse, SWT.FocusIn };
-		for (int i = 0; i < textEvents.length; i++) {
-			text.addListener(textEvents[i], listener);
-		}
-	}
-
-	static int checkStyle(int style) {
-		int mask = SWT.BORDER | SWT.READ_ONLY | SWT.FLAT | SWT.LEFT_TO_RIGHT
-				| SWT.RIGHT_TO_LEFT;
-		return style & mask;
-	}
-
-	/**
-	 * Adds the argument to the end of the receiver's list.
-	 * 
-	 * @param string
-	 *            the new item
-	 * 
-	 * @exception IllegalArgumentException
-	 *                <ul>
-	 *                <li>ERROR_NULL_ARGUMENT - if the string is null</li>
-	 *                </ul>
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 * 
-	 * @see #add(String,int)
-	 */
-	public void add(String string) {
-		checkWidget();
-		if (string == null) {
-			SWT.error(SWT.ERROR_NULL_ARGUMENT);
-		}
-		TableItem item = new TableItem(table, SWT.NONE);
-		item.setText(0, string);
-	}
-
-	/**
-	 * Adds the argument to the receiver's list at the given zero-relative
-	 * index.
-	 * <p>
-	 * Note: To add an item at the end of the list, use the result of calling
-	 * <code>getItemCount()</code> as the index or use
-	 * <code>add(String)</code>.
-	 * </p>
-	 * 
-	 * @param string
-	 *            the new item
-	 * @param index
-	 *            the index for the item
-	 * 
-	 * @exception IllegalArgumentException
-	 *                <ul>
-	 *                <li>ERROR_NULL_ARGUMENT - if the string is null</li>
-	 *                <li>ERROR_INVALID_RANGE - if the index is not between 0
-	 *                and the number of elements in the list (inclusive)</li>
-	 *                </ul>
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 * 
-	 * @see #add(String)
-	 */
-	public void add(String string, int index) {
-		checkWidget();
-		if (string == null) {
-			SWT.error(SWT.ERROR_NULL_ARGUMENT);
-		}
-		TableItem item = new TableItem(table, SWT.NONE, index);
-		item.setText(0, string);
-	}
-
-	/**
-	 * Adds the listener to the collection of listeners who will be notified
-	 * when the receiver's text is modified, by sending it one of the messages
-	 * defined in the <code>ModifyListener</code> interface.
-	 * 
-	 * @param listener1
-	 *            the listener which should be notified
-	 * 
-	 * @exception IllegalArgumentException
-	 *                <ul>
-	 *                <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
-	 *                </ul>
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 * 
-	 * @see ModifyListener
-	 * @see #removeModifyListener
-	 */
-	public void addModifyListener(ModifyListener listener1) {
-		checkWidget();
-		if (listener1 == null) {
-			SWT.error(SWT.ERROR_NULL_ARGUMENT);
-		}
-		TypedListener typedListener = new TypedListener(listener1);
-		addListener(SWT.Modify, typedListener);
-	}
-
-	/**
-	 * Adds the listener to the collection of listeners who will be notified
-	 * when the receiver's selection changes, by sending it one of the messages
-	 * defined in the <code>SelectionListener</code> interface.
-	 * <p>
-	 * <code>widgetSelected</code> is called when the combo's list selection
-	 * changes. <code>widgetDefaultSelected</code> is typically called when
-	 * ENTER is pressed the combo's text area.
-	 * </p>
-	 * 
-	 * @param listener1
-	 *            the listener which should be notified
-	 * 
-	 * @exception IllegalArgumentException
-	 *                <ul>
-	 *                <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
-	 *                </ul>
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 * 
-	 * @see SelectionListener
-	 * @see #removeSelectionListener
-	 */
-	public void addSelectionListener(SelectionListener listener1) {
-		checkWidget();
-		if (listener1 == null) {
-			SWT.error(SWT.ERROR_NULL_ARGUMENT);
-		}
-		TypedListener typedListener = new TypedListener(listener1);
-		addListener(SWT.Selection, typedListener);
-		addListener(SWT.DefaultSelection, typedListener);
-	}
-
-	void arrowEvent(Event event) {
-		switch (event.type) {
-		case SWT.FocusIn: {
-			handleFocus(SWT.FocusIn);
-			break;
-		}
-		case SWT.Selection: {
-			dropDown(!isDropped());
-			break;
-		}
-		}
-	}
-
-	/**
-	 * Sets the selection in the receiver's text field to an empty selection
-	 * starting just before the first character. If the text field is editable,
-	 * this has the effect of placing the i-beam at the start of the text.
-	 * <p>
-	 * Note: To clear the selected items in the receiver's list, use
-	 * <code>deselectAll()</code>.
-	 * </p>
-	 * 
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 * 
-	 * @see #deselectAll
-	 */
-	public void clearSelection() {
-		checkWidget();
-		text.clearSelection();
-		table.deselectAll();
-	}
-
-	void comboEvent(Event event) {
-		switch (event.type) {
-		case SWT.Dispose:
-			if (popup != null && !popup.isDisposed()) {
-				table.removeListener(SWT.Dispose, listener);
-				popup.dispose();
-			}
-			Shell shell = getShell();
-			shell.removeListener(SWT.Deactivate, listener);
-			Display display = getDisplay();
-			display.removeFilter(SWT.FocusIn, filter);
-			popup = null;
-			text = null;
-			table = null;
-			arrow = null;
-			break;
-		case SWT.Move:
-			dropDown(false);
-			break;
-		case SWT.Resize:
-			internalLayout(false);
-			break;
-		}
-	}
-
-	private String[] getTableItems() {
-		TableItem[] items = table.getItems();
-		String[] values = new String[items.length];
-		for (int i = 0; i < items.length; i++) {
-			values[i] = items[i].getText(0);
-		}
-		return values;
-	}
-
-	public Point computeSize(int wHint, int hHint, boolean changed) {
-		checkWidget();
-		int width = 0, height = 0;
-		String[] items = getTableItems();
-		int textWidth = 0;
-		GC gc = new GC(text);
-		int spacer = gc.stringExtent(" ").x; //$NON-NLS-1$
-		for (int i = 0; i < items.length; i++) {
-			textWidth = Math.max(gc.stringExtent(items[i]).x, textWidth);
-		}
-		gc.dispose();
-		Point textSize = text.computeSize(SWT.DEFAULT, SWT.DEFAULT, changed);
-		Point arrowSize = arrow.computeSize(SWT.DEFAULT, SWT.DEFAULT, changed);
-		Point listSize = table.computeSize(wHint, SWT.DEFAULT, changed);
-		int borderWidth = getBorderWidth();
-
-		height = Math.max(hHint, Math.max(textSize.y, arrowSize.y) + 2
-				* borderWidth);
-		width = Math.max(wHint, Math.max(textWidth + 2 * spacer + arrowSize.x
-				+ 2 * borderWidth, listSize.x));
-		return new Point(width, height);
-	}
-
-	void createPopup(String[] items, int selectionIndex) {
-		// create shell and list
-		popup = new Shell(getShell(), SWT.NO_TRIM | SWT.ON_TOP);
-		table = new Table(popup, SWT.SINGLE | SWT.V_SCROLL | SWT.FULL_SELECTION);
-		new TableColumn(table, SWT.LEFT);
-		if (font != null) {
-			table.setFont(font);
-		}
-		if (foreground != null) {
-			table.setForeground(foreground);
-		}
-		if (background != null) {
-			table.setBackground(background);
-		}
-
-		int[] popupEvents = { SWT.Close, SWT.Paint, SWT.Deactivate };
-		for (int i = 0; i < popupEvents.length; i++) {
-			popup.addListener(popupEvents[i], listener);
-		}
-		int[] listEvents = { SWT.MouseUp, SWT.Selection, SWT.Traverse,
-				SWT.KeyDown, SWT.KeyUp, SWT.FocusIn, SWT.FocusOut, SWT.Dispose };
-		for (int i = 0; i < listEvents.length; i++) {
-			table.addListener(listEvents[i], listener);
-		}
-		if (items != null) {
-			setItems(items);
-		}
-		if (selectionIndex != -1) {
-			select(selectionIndex);
-		}
-	}
-
-	/**
-	 * Deselects the item at the given zero-relative index in the receiver's
-	 * list. If the item at the index was already deselected, it remains
-	 * deselected. Indices that are out of range are ignored.
-	 * 
-	 * @param index
-	 *            the index of the item to deselect
-	 * 
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public void deselect(int index) {
-		checkWidget();
-		table.deselect(index);
-	}
-
-	/**
-	 * Deselects all selected items in the receiver's list.
-	 * <p>
-	 * Note: To clear the selection in the receiver's text field, use
-	 * <code>clearSelection()</code>.
-	 * </p>
-	 * 
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 * 
-	 * @see #clearSelection
-	 */
-	public void deselectAll() {
-		checkWidget();
-		table.deselectAll();
-	}
-
-	void dropDown(boolean drop) {
-		if (drop == isDropped()) {
-			return;
-		}
-		if (!drop) {
-			popup.setVisible(false);
-			table.getColumns()[0].setWidth(0);
-			if (!isDisposed() && arrow.isFocusControl()) {
-				text.setFocus();
-			}
-			return;
-		}
-
-		if (getShell() != popup.getParent()) {
-			String[] items = getTableItems();
-			int selectionIndex = table.getSelectionIndex();
-			table.removeListener(SWT.Dispose, listener);
-			popup.dispose();
-			popup = null;
-			table = null;
-			createPopup(items, selectionIndex);
-		}
-
-		Point size = getSize();
-		int itemCount = table.getItemCount();
-		itemCount = (itemCount == 0) ? visibleItemCount : Math.min(
-				visibleItemCount, itemCount);
-		int itemHeight = table.getItemHeight() * itemCount;
-		Point tableSize = table.computeSize(SWT.DEFAULT, itemHeight, false);
-		// int tableWidth = this.getClientArea()
-		table.setBounds(1, 1, Math.max(size.x - 2, tableSize.x), tableSize.y
-				- table.getHorizontalBar().getSize().y + 2);
-
-		int index = table.getSelectionIndex();
-		if (index != -1) {
-			table.setTopIndex(index);
-		}
-		Display display = getDisplay();
-		Rectangle tableRect = table.getBounds();
-		Rectangle parentRect = display.map(getParent(), null, getBounds());
-		Point comboSize = getSize();
-		Rectangle displayRect = getMonitor().getClientArea();
-		int width = Math.max(comboSize.x, tableRect.width + 2);
-		int height = tableRect.height + 2;
-		int x = parentRect.x;
-		int y = parentRect.y + comboSize.y;
-		if (y + height > displayRect.y + displayRect.height) {
-			y = parentRect.y - height;
-		}
-		popup.setBounds(x, y, width, height);
-		popup.setVisible(true);
-
-		if (table.getItemCount() > visibleItemCount) {
-			table.getColumns()[0].setWidth(text.getSize().x - 2);
-		} else {
-			table.getColumns()[0].setWidth(table.getClientArea().width);
-		}
-		table.setFocus();
-	}
-
-	/*
-	 * Return the Label immediately preceding the receiver in the z-order, or
-	 * null if none.
-	 */
-	Label getAssociatedLabel() {
-		Control[] siblings = getParent().getChildren();
-		for (int i = 0; i < siblings.length; i++) {
-			if (siblings[i] == StyleCombo.this) {
-				if (i > 0 && siblings[i - 1] instanceof Label) {
-					return (Label) siblings[i - 1];
-				}
-			}
-		}
-		return null;
-	}
-
-	public Control[] getChildren() {
-		checkWidget();
-		return new Control[0];
-	}
-
-	/**
-	 * Gets the editable state.
-	 * 
-	 * @return whether or not the reciever is editable
-	 * 
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 * 
-	 * @since 3.0
-	 */
-	public boolean getEditable() {
-		checkWidget();
-		return text.getEditable();
-	}
-
-	/**
-	 * Returns the item at the given, zero-relative index in the receiver's
-	 * list. Throws an exception if the index is out of range.
-	 * 
-	 * @param index
-	 *            the index of the item to return
-	 * @return the item at the given index
-	 * 
-	 * @exception IllegalArgumentException
-	 *                <ul>
-	 *                <li>ERROR_INVALID_RANGE - if the index is not between 0
-	 *                and the number of elements in the list minus 1 (inclusive)</li>
-	 *                </ul>
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public String getItem(int index) {
-		checkWidget();
-		return table.getItem(index).getText(0);
-	}
-
-	/**
-	 * Returns the number of items contained in the receiver's list.
-	 * 
-	 * @return the number of items
-	 * 
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public int getItemCount() {
-		checkWidget();
-		return table.getItemCount();
-	}
-
-	/**
-	 * Returns the height of the area which would be used to display
-	 * <em>one</em> of the items in the receiver's list.
-	 * 
-	 * @return the height of one item
-	 * 
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public int getItemHeight() {
-		checkWidget();
-		return table.getItemHeight();
-	}
-
-	/**
-	 * Returns an array of <code>String</code>s which are the items in the
-	 * receiver's list.
-	 * <p>
-	 * Note: This is not the actual structure used by the receiver to maintain
-	 * its list of items, so modifying the array will not affect the receiver.
-	 * </p>
-	 * 
-	 * @return the items in the receiver's list
-	 * 
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public String[] getItems() {
-		checkWidget();
-		return getTableItems();
-	}
-
-	char getMnemonic(String string) {
-		int index = 0;
-		int length = string.length();
-		do {
-			while ((index < length) && (string.charAt(index) != '&')) {
-				index++;
-			}
-			if (++index >= length) {
-				return '\0';
-			}
-			if (string.charAt(index) != '&') {
-				return string.charAt(index);
-			}
-			index++;
-		} while (index < length);
-		return '\0';
-	}
-
-	/**
-	 * Returns a <code>Point</code> whose x coordinate is the start of the
-	 * selection in the receiver's text field, and whose y coordinate is the end
-	 * of the selection. The returned values are zero-relative. An "empty"
-	 * selection as indicated by the the x and y coordinates having the same
-	 * value.
-	 * 
-	 * @return a point representing the selection start and end
-	 * 
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public Point getSelection() {
-		checkWidget();
-		return text.getSelection();
-	}
-
-	/**
-	 * Returns the zero-relative index of the item which is currently selected
-	 * in the receiver's list, or -1 if no item is selected.
-	 * 
-	 * @return the index of the selected item
-	 * 
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public int getSelectionIndex() {
-		checkWidget();
-		return table.getSelectionIndex();
-	}
-
-	public int getStyle() {
-		int style = super.getStyle();
-		style &= ~SWT.READ_ONLY;
-		if (!text.getEditable()) {
-			style |= SWT.READ_ONLY;
-		}
-		return style;
-	}
-
-	/**
-	 * Returns a string containing a copy of the contents of the receiver's text
-	 * field.
-	 * 
-	 * @return the receiver's text
-	 * 
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public String getText() {
-		checkWidget();
-		return text.getText();
-	}
-
-	/**
-	 * Returns the height of the receivers's text field.
-	 * 
-	 * @return the text height
-	 * 
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public int getTextHeight() {
-		checkWidget();
-		return text.getLineHeight();
-	}
-
-	/**
-	 * Returns the maximum number of characters that the receiver's text field
-	 * is capable of holding. If this has not been changed by
-	 * <code>setTextLimit()</code>, it will be the constant
-	 * <code>Combo.LIMIT</code>.
-	 * 
-	 * @return the text limit
-	 * 
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public int getTextLimit() {
-		checkWidget();
-		return text.getTextLimit();
-	}
-
-	/**
-	 * Gets the number of items that are visible in the drop down portion of the
-	 * receiver's list.
-	 * 
-	 * @return the number of items that are visible
-	 * 
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 * 
-	 * @since 3.0
-	 */
-	public int getVisibleItemCount() {
-		checkWidget();
-		return visibleItemCount;
-	}
-
-	void handleFocus(int type) {
-		if (isDisposed()) {
-			return;
-		}
-		switch (type) {
-		case SWT.FocusIn: {
-			if (hasFocus) {
-				return;
-			}
-			if (getEditable()) {
-				text.selectAll();
-			}
-			hasFocus = true;
-			Shell shell = getShell();
-			shell.removeListener(SWT.Deactivate, listener);
-			shell.addListener(SWT.Deactivate, listener);
-			Display display = getDisplay();
-			display.removeFilter(SWT.FocusIn, filter);
-			display.addFilter(SWT.FocusIn, filter);
-			Event e = new Event();
-			notifyListeners(SWT.FocusIn, e);
-			break;
-		}
-		case SWT.FocusOut: {
-			if (!hasFocus) {
-				return;
-			}
-			Control focusControl = getDisplay().getFocusControl();
-			if (focusControl == arrow || focusControl == table
-					|| focusControl == text) {
-				return;
-			}
-			hasFocus = false;
-			Shell shell = getShell();
-			shell.removeListener(SWT.Deactivate, listener);
-			Display display = getDisplay();
-			display.removeFilter(SWT.FocusIn, filter);
-			Event e = new Event();
-			notifyListeners(SWT.FocusOut, e);
-			break;
-		}
-		}
-	}
-
-	/**
-	 * Searches the receiver's list starting at the first item (index 0) until
-	 * an item is found that is equal to the argument, and returns the index of
-	 * that item. If no item is found, returns -1.
-	 * 
-	 * @param string
-	 *            the search item
-	 * @return the index of the item
-	 * 
-	 * @exception IllegalArgumentException
-	 *                <ul>
-	 *                <li>ERROR_NULL_ARGUMENT - if the string is null</li>
-	 *                </ul>
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public int indexOf(String string) {
-		checkWidget();
-		if (string == null) {
-			SWT.error(SWT.ERROR_NULL_ARGUMENT);
-		}
-		return Arrays.asList(getTableItems()).indexOf(string);
-	}
-
-	/**
-	 * Searches the receiver's list starting at the given, zero-relative index
-	 * until an item is found that is equal to the argument, and returns the
-	 * index of that item. If no item is found or the starting index is out of
-	 * range, returns -1.
-	 * 
-	 * @param string
-	 *            the search item
-	 * @param start
-	 *            the zero-relative index at which to begin the search
-	 * @return the index of the item
-	 * 
-	 * @exception IllegalArgumentException
-	 *                <ul>
-	 *                <li>ERROR_NULL_ARGUMENT - if the string is null</li>
-	 *                </ul>
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public int indexOf(String string, int start) {
-		checkWidget();
-		if (string == null) {
-			SWT.error(SWT.ERROR_NULL_ARGUMENT);
-		}
-		String[] items = getTableItems();
-		for (int i = start; i < items.length; i++) {
-			if (items[i].equals(string)) {
-				return i;
-			}
-		}
-		return -1;
-	}
-
-	void initAccessible() {
-		AccessibleAdapter accessibleAdapter = new AccessibleAdapter() {
-			public void getName(AccessibleEvent e) {
-				String name = null;
-				Label label = getAssociatedLabel();
-				if (label != null) {
-					name = stripMnemonic(label.getText());
-				}
-				e.result = name;
-			}
-
-			public void getKeyboardShortcut(AccessibleEvent e) {
-				String shortcut = null;
-				Label label = getAssociatedLabel();
-				if (label != null) {
-					String text1 = label.getText();
-					if (text1 != null) {
-						char mnemonic = getMnemonic(text1);
-						if (mnemonic != '\0') {
-							shortcut = "Alt+" + mnemonic; //$NON-NLS-1$
-						}
-					}
-				}
-				e.result = shortcut;
-			}
-
-			public void getHelp(AccessibleEvent e) {
-				e.result = getToolTipText();
-			}
-		};
-		getAccessible().addAccessibleListener(accessibleAdapter);
-		text.getAccessible().addAccessibleListener(accessibleAdapter);
-		table.getAccessible().addAccessibleListener(accessibleAdapter);
-
-		arrow.getAccessible().addAccessibleListener(new AccessibleAdapter() {
-			public void getName(AccessibleEvent e) {
-				e.result = isDropped() ? SWT.getMessage("SWT_Close") : SWT.getMessage("SWT_Open"); //$NON-NLS-1$ //$NON-NLS-2$
-			}
-
-			public void getKeyboardShortcut(AccessibleEvent e) {
-				e.result = "Alt+Down Arrow"; //$NON-NLS-1$
-			}
-
-			public void getHelp(AccessibleEvent e) {
-				e.result = getToolTipText();
-			}
-		});
-
-		getAccessible().addAccessibleTextListener(new AccessibleTextAdapter() {
-			public void getCaretOffset(AccessibleTextEvent e) {
-				e.offset = text.getCaretPosition();
-			}
-		});
-
-		getAccessible().addAccessibleControlListener(
-				new AccessibleControlAdapter() {
-					public void getChildAtPoint(AccessibleControlEvent e) {
-						Point testPoint = toControl(e.x, e.y);
-						if (getBounds().contains(testPoint)) {
-							e.childID = ACC.CHILDID_SELF;
-						}
-					}
-
-					public void getLocation(AccessibleControlEvent e) {
-						Rectangle location = getBounds();
-						Point pt = toDisplay(location.x, location.y);
-						e.x = pt.x;
-						e.y = pt.y;
-						e.width = location.width;
-						e.height = location.height;
-					}
-
-					public void getChildCount(AccessibleControlEvent e) {
-						e.detail = 0;
-					}
-
-					public void getRole(AccessibleControlEvent e) {
-						e.detail = ACC.ROLE_COMBOBOX;
-					}
-
-					public void getState(AccessibleControlEvent e) {
-						e.detail = ACC.STATE_NORMAL;
-					}
-
-					public void getValue(AccessibleControlEvent e) {
-						e.result = getText();
-					}
-				});
-
-		text.getAccessible().addAccessibleControlListener(
-				new AccessibleControlAdapter() {
-					public void getRole(AccessibleControlEvent e) {
-						e.detail = text.getEditable() ? ACC.ROLE_TEXT
-								: ACC.ROLE_LABEL;
-					}
-				});
-
-		arrow.getAccessible().addAccessibleControlListener(
-				new AccessibleControlAdapter() {
-					public void getDefaultAction(AccessibleControlEvent e) {
-						e.result = isDropped() ? SWT.getMessage("SWT_Close") : SWT.getMessage("SWT_Open"); //$NON-NLS-1$ //$NON-NLS-2$
-					}
-				});
-	}
-
-	boolean isDropped() {
-		return popup.getVisible();
-	}
-
-	public boolean isFocusControl() {
-		checkWidget();
-		if (text.isFocusControl() || arrow.isFocusControl()
-				|| table.isFocusControl() || popup.isFocusControl()) {
-			return true;
-		}
-		return super.isFocusControl();
-	}
-
-	void internalLayout(boolean changed) {
-		if (isDropped()) {
-			dropDown(false);
-		}
-		Rectangle rect = getClientArea();
-		int width = rect.width;
-		int height = rect.height;
-		Point arrowSize = arrow.computeSize(SWT.DEFAULT, height, changed);
-		text.setBounds(0, 0, width - arrowSize.x, height);
-		arrow.setBounds(width - arrowSize.x, 0, arrowSize.x, arrowSize.y);
-	}
-
-	void tableEvent(Event event) {
-		switch (event.type) {
-		case SWT.Dispose:
-			if (getShell() != popup.getParent()) {
-				String[] items = getTableItems();
-				int selectionIndex = table.getSelectionIndex();
-				popup = null;
-				table = null;
-				createPopup(items, selectionIndex);
-			}
-			break;
-		case SWT.FocusIn: {
-			handleFocus(SWT.FocusIn);
-			break;
-		}
-		case SWT.MouseUp: {
-			if (event.button != 1) {
-				return;
-			}
-			dropDown(false);
-			break;
-		}
-		case SWT.Selection: {
-			int index = table.getSelectionIndex();
-			if (index == -1)
-				return;
-			text.setText(table.getItem(index).getText());
-			text.selectAll();
-			table.setSelection(index);
-			Event e = new Event();
-			e.time = event.time;
-			e.stateMask = event.stateMask;
-			e.doit = event.doit;
-			notifyListeners(SWT.Selection, e);
-			event.doit = e.doit;
-			break;
-		}
-		case SWT.Traverse: {
-			switch (event.detail) {
-			case SWT.TRAVERSE_RETURN:
-			case SWT.TRAVERSE_ESCAPE:
-			case SWT.TRAVERSE_ARROW_PREVIOUS:
-			case SWT.TRAVERSE_ARROW_NEXT:
-				event.doit = false;
-				break;
-			}
-			Event e = new Event();
-			e.time = event.time;
-			e.detail = event.detail;
-			e.doit = event.doit;
-			e.character = event.character;
-			e.keyCode = event.keyCode;
-			notifyListeners(SWT.Traverse, e);
-			event.doit = e.doit;
-			event.detail = e.detail;
-			break;
-		}
-		case SWT.KeyUp: {
-			Event e = new Event();
-			e.time = event.time;
-			e.character = event.character;
-			e.keyCode = event.keyCode;
-			e.stateMask = event.stateMask;
-			notifyListeners(SWT.KeyUp, e);
-			break;
-		}
-		case SWT.KeyDown: {
-			if (event.character == SWT.ESC) {
-				// Escape key cancels popup list
-				dropDown(false);
-			}
-			if ((event.stateMask & SWT.ALT) != 0
-					&& (event.keyCode == SWT.ARROW_UP || event.keyCode == SWT.ARROW_DOWN)) {
-				dropDown(false);
-			}
-			if (event.character == SWT.CR) {
-				// Enter causes default selection
-				dropDown(false);
-				Event e = new Event();
-				e.time = event.time;
-				e.stateMask = event.stateMask;
-				notifyListeners(SWT.DefaultSelection, e);
-			}
-			// At this point the widget may have been disposed.
-			// If so, do not continue.
-			if (isDisposed()) {
-				break;
-			}
-			Event e = new Event();
-			e.time = event.time;
-			e.character = event.character;
-			e.keyCode = event.keyCode;
-			e.stateMask = event.stateMask;
-			notifyListeners(SWT.KeyDown, e);
-			break;
-
-		}
-		}
-	}
-
-	void popupEvent(Event event) {
-		switch (event.type) {
-		case SWT.Paint:
-			// draw black rectangle around list
-			Rectangle listRect = table.getBounds();
-			Color black = getDisplay().getSystemColor(SWT.COLOR_BLACK);
-			event.gc.setForeground(black);
-			event.gc.drawRectangle(0, 0, listRect.width + 1,
-					listRect.height + 1);
-			break;
-		case SWT.Close:
-			event.doit = false;
-			dropDown(false);
-			break;
-		case SWT.Deactivate:
-			dropDown(false);
-			break;
-		}
-	}
-
-	public void redraw() {
-		super.redraw();
-		text.redraw();
-		arrow.redraw();
-		if (popup.isVisible()) {
-			table.redraw();
-		}
-	}
-
-	public void redraw(int x, int y, int width, int height, boolean all) {
-		super.redraw(x, y, width, height, true);
-	}
-
-	/**
-	 * Removes the item from the receiver's list at the given zero-relative
-	 * index.
-	 * 
-	 * @param index
-	 *            the index for the item
-	 * 
-	 * @exception IllegalArgumentException
-	 *                <ul>
-	 *                <li>ERROR_INVALID_RANGE - if the index is not between 0
-	 *                and the number of elements in the list minus 1 (inclusive)</li>
-	 *                </ul>
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public void remove(int index) {
-		checkWidget();
-		table.remove(index);
-	}
-
-	/**
-	 * Removes the items from the receiver's list which are between the given
-	 * zero-relative start and end indices (inclusive).
-	 * 
-	 * @param start
-	 *            the start of the range
-	 * @param end
-	 *            the end of the range
-	 * 
-	 * @exception IllegalArgumentException
-	 *                <ul>
-	 *                <li>ERROR_INVALID_RANGE - if either the start or end are
-	 *                not between 0 and the number of elements in the list minus
-	 *                1 (inclusive)</li>
-	 *                </ul>
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public void remove(int start, int end) {
-		checkWidget();
-		table.remove(start, end);
-	}
-
-	/**
-	 * Searches the receiver's list starting at the first item until an item is
-	 * found that is equal to the argument, and removes that item from the list.
-	 * 
-	 * @param string
-	 *            the item to remove
-	 * 
-	 * @exception IllegalArgumentException
-	 *                <ul>
-	 *                <li>ERROR_NULL_ARGUMENT - if the string is null</li>
-	 *                <li>ERROR_INVALID_ARGUMENT - if the string is not found
-	 *                in the list</li>
-	 *                </ul>
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public void remove(String string) {
-		checkWidget();
-		if (string == null) {
-			SWT.error(SWT.ERROR_NULL_ARGUMENT);
-		}
-		int index = Arrays.asList(getTableItems()).indexOf(string);
-		table.remove(index);
-	}
-
-	/**
-	 * Removes all of the items from the receiver's list and clear the contents
-	 * of receiver's text field.
-	 * <p>
-	 * 
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public void removeAll() {
-		checkWidget();
-		text.setText(""); //$NON-NLS-1$
-		table.removeAll();
-	}
-
-	/**
-	 * Removes the listener from the collection of listeners who will be
-	 * notified when the receiver's text is modified.
-	 * 
-	 * @param listener1
-	 *            the listener which should no longer be notified
-	 * 
-	 * @exception IllegalArgumentException
-	 *                <ul>
-	 *                <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
-	 *                </ul>
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 * 
-	 * @see ModifyListener
-	 * @see #addModifyListener
-	 */
-	public void removeModifyListener(ModifyListener listener1) {
-		checkWidget();
-		if (listener1 == null) {
-			SWT.error(SWT.ERROR_NULL_ARGUMENT);
-		}
-		removeListener(SWT.Modify, listener1);
-	}
-
-	/**
-	 * Removes the listener from the collection of listeners who will be
-	 * notified when the receiver's selection changes.
-	 * 
-	 * @param listener1
-	 *            the listener which should no longer be notified
-	 * 
-	 * @exception IllegalArgumentException
-	 *                <ul>
-	 *                <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
-	 *                </ul>
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 * 
-	 * @see SelectionListener
-	 * @see #addSelectionListener
-	 */
-	public void removeSelectionListener(SelectionListener listener1) {
-		checkWidget();
-		if (listener1 == null) {
-			SWT.error(SWT.ERROR_NULL_ARGUMENT);
-		}
-		removeListener(SWT.Selection, listener1);
-		removeListener(SWT.DefaultSelection, listener1);
-	}
-
-	/**
-	 * Selects the item at the given zero-relative index in the receiver's list.
-	 * If the item at the index was already selected, it remains selected.
-	 * Indices that are out of range are ignored.
-	 * 
-	 * @param index
-	 *            the index of the item to select
-	 * 
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public void select(int index) {
-		checkWidget();
-		if (index == -1) {
-			table.deselectAll();
-			text.setText(""); //$NON-NLS-1$
-			return;
-		}
-		if (0 <= index && index < table.getItemCount()) {
-			if (index != getSelectionIndex()) {
-				text.setText(table.getItem(index).getText());
-				text.selectAll();
-				table.select(index);
-				table.showSelection();
-			}
-		}
-	}
-
-	public void setBackground(Color color) {
-		super.setBackground(color);
-		background = color;
-		if (text != null) {
-			text.setBackground(color);
-		}
-		if (table != null) {
-			table.setBackground(color);
-		}
-		if (arrow != null) {
-			arrow.setBackground(color);
-		}
-	}
-
-	/**
-	 * Sets the editable state.
-	 * 
-	 * @param editable
-	 *            the new editable state
-	 * 
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 * 
-	 * @since 3.0
-	 */
-	public void setEditable(boolean editable) {
-		checkWidget();
-		text.setEditable(editable);
-	}
-
-	public void setEnabled(boolean enabled) {
-		super.setEnabled(enabled);
-		if (popup != null) {
-			popup.setVisible(false);
-		}
-		if (text != null) {
-			text.setEnabled(enabled);
-		}
-		if (arrow != null) {
-			arrow.setEnabled(enabled);
-		}
-	}
-
-	public boolean setFocus() {
-		checkWidget();
-		return text.setFocus();
-	}
-
-	public void setFont(Font font) {
-		super.setFont(font);
-		this.font = font;
-		text.setFont(font);
-		table.setFont(font);
-		internalLayout(true);
-	}
-
-	public void setForeground(Color color) {
-		super.setForeground(color);
-		foreground = color;
-		if (text != null) {
-			text.setForeground(color);
-		}
-		if (table != null) {
-			table.setForeground(color);
-		}
-		if (arrow != null) {
-			arrow.setForeground(color);
-		}
-	}
-
-	/**
-	 * Sets the text of the item in the receiver's list at the given
-	 * zero-relative index to the string argument. This is equivalent to
-	 * <code>remove</code>'ing the old item at the index, and then
-	 * <code>add</code>'ing the new item at that index.
-	 * 
-	 * @param index
-	 *            the index for the item
-	 * @param string
-	 *            the new text for the item
-	 * 
-	 * @exception IllegalArgumentException
-	 *                <ul>
-	 *                <li>ERROR_INVALID_RANGE - if the index is not between 0
-	 *                and the number of elements in the list minus 1 (inclusive)</li>
-	 *                <li>ERROR_NULL_ARGUMENT - if the string is null</li>
-	 *                </ul>
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public void setItem(int index, String string) {
-		checkWidget();
-		table.getItem(index).setText(0, string);
-	}
-
-	/**
-	 * Sets the receiver's list to be the given array of items.
-	 * 
-	 * @param items
-	 *            the array of items
-	 * 
-	 * @exception IllegalArgumentException
-	 *                <ul>
-	 *                <li>ERROR_NULL_ARGUMENT - if the items array is null</li>
-	 *                <li>ERROR_INVALID_ARGUMENT - if an item in the items
-	 *                array is null</li>
-	 *                </ul>
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public void setItems(String[] items) {
-		checkWidget();
-		if (items == null) {
-			SWT.error(SWT.ERROR_NULL_ARGUMENT);
-		}
-
-		for (int i = 0; i < items.length; i++) {
-			TableItem item = new TableItem(table, SWT.NONE);
-			if (items[i].equals(defaultValue)) {
-				item.setFont(JFaceResources.getFontRegistry().getBold(
-						JFaceResources.DEFAULT_FONT));
-			}
-			item.setText(0, items[i]);
-		}
-	}
-
-	/**
-	 * Sets the layout which is associated with the receiver to be the argument
-	 * which may be null.
-	 * <p>
-	 * Note : No Layout can be set on this Control because it already manages
-	 * the size and position of its children.
-	 * </p>
-	 * 
-	 * @param layout
-	 *            the receiver's new layout or null
-	 * 
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public void setLayout(Layout layout) {
-		checkWidget();
-		return;
-	}
-
-	/**
-	 * Sets the selection in the receiver's text field to the range specified by
-	 * the argument whose x coordinate is the start of the selection and whose y
-	 * coordinate is the end of the selection.
-	 * 
-	 * @param selection
-	 *            a point representing the new selection start and end
-	 * 
-	 * @exception IllegalArgumentException
-	 *                <ul>
-	 *                <li>ERROR_NULL_ARGUMENT - if the point is null</li>
-	 *                </ul>
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public void setSelection(Point selection) {
-		checkWidget();
-		if (selection == null) {
-			SWT.error(SWT.ERROR_NULL_ARGUMENT);
-		}
-		text.setSelection(selection.x, selection.y);
-	}
-
-	/**
-	 * Sets the contents of the receiver's text field to the given string.
-	 * <p>
-	 * Note: The text field in a <code>Combo</code> is typically only capable
-	 * of displaying a single line of text. Thus, setting the text to a string
-	 * containing line breaks or other special characters will probably cause it
-	 * to display incorrectly.
-	 * </p>
-	 * 
-	 * @param string
-	 *            the new text
-	 * 
-	 * @exception IllegalArgumentException
-	 *                <ul>
-	 *                <li>ERROR_NULL_ARGUMENT - if the string is null</li>
-	 *                </ul>
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public void setText(String string) {
-		checkWidget();
-		if (string == null) {
-			SWT.error(SWT.ERROR_NULL_ARGUMENT);
-		}
-		int index = Arrays.asList(getTableItems()).indexOf(string);
-		if (index == -1) {
-			table.deselectAll();
-			text.setText(string);
-			return;
-		}
-		text.setText(string);
-		text.selectAll();
-		table.setSelection(index);
-		table.showSelection();
-	}
-
-	/**
-	 * Sets the maximum number of characters that the receiver's text field is
-	 * capable of holding to be the argument.
-	 * 
-	 * @param limit
-	 *            new text limit
-	 * 
-	 * @exception IllegalArgumentException
-	 *                <ul>
-	 *                <li>ERROR_CANNOT_BE_ZERO - if the limit is zero</li>
-	 *                </ul>
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 */
-	public void setTextLimit(int limit) {
-		checkWidget();
-		text.setTextLimit(limit);
-	}
-
-	public void setToolTipText(String string) {
-		checkWidget();
-		super.setToolTipText(string);
-		arrow.setToolTipText(string);
-		text.setToolTipText(string);
-	}
-
-	public void setVisible(boolean visible) {
-		super.setVisible(visible);
-		if (!visible) {
-			popup.setVisible(false);
-		}
-	}
-
-	/**
-	 * Sets the number of items that are visible in the drop down portion of the
-	 * receiver's list.
-	 * 
-	 * @param count
-	 *            the new number of items to be visible
-	 * 
-	 * @exception org.eclipse.swt.SWTException
-	 *                <ul>
-	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
-	 *                disposed</li>
-	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
-	 *                thread that created the receiver</li>
-	 *                </ul>
-	 * 
-	 * @since 3.0
-	 */
-	public void setVisibleItemCount(int count) {
-		checkWidget();
-		if (count < 0) {
-			return;
-		}
-		visibleItemCount = count;
-	}
-
-	String stripMnemonic(String string) {
-		int index = 0;
-		int length = string.length();
-		do {
-			while ((index < length) && (string.charAt(index) != '&')) {
-				index++;
-			}
-			if (++index >= length) {
-				return string;
-			}
-			if (string.charAt(index) != '&') {
-				return string.substring(0, index - 1)
-						+ string.substring(index, length);
-			}
-			index++;
-		} while (index < length);
-		return string;
-	}
-
-	void textEvent(Event event) {
-		switch (event.type) {
-		case SWT.FocusIn: {
-			handleFocus(SWT.FocusIn);
-			break;
-		}
-		case SWT.KeyDown: {
-			if (event.character == SWT.CR) {
-				dropDown(false);
-				Event e = new Event();
-				e.time = event.time;
-				e.stateMask = event.stateMask;
-				notifyListeners(SWT.DefaultSelection, e);
-			}
-			// At this point the widget may have been disposed.
-			// If so, do not continue.
-			if (isDisposed()) {
-				break;
-			}
-
-			if (event.keyCode == SWT.ARROW_UP
-					|| event.keyCode == SWT.ARROW_DOWN) {
-				event.doit = false;
-				if ((event.stateMask & SWT.ALT) != 0) {
-					boolean dropped = isDropped();
-					text.selectAll();
-					if (!dropped) {
-						setFocus();
-					}
-					dropDown(!dropped);
-					break;
-				}
-
-				int oldIndex = getSelectionIndex();
-				if (event.keyCode == SWT.ARROW_UP) {
-					select(Math.max(oldIndex - 1, 0));
-				} else {
-					select(Math.min(oldIndex + 1, getItemCount() - 1));
-				}
-				if (oldIndex != getSelectionIndex()) {
-					Event e = new Event();
-					e.time = event.time;
-					e.stateMask = event.stateMask;
-					notifyListeners(SWT.Selection, e);
-				}
-				// At this point the widget may have been disposed.
-				// If so, do not continue.
-				if (isDisposed()) {
-					break;
-				}
-			}
-
-			// Further work : Need to add support for incremental search in
-			// pop up list as characters typed in text widget
-
-			Event e = new Event();
-			e.time = event.time;
-			e.character = event.character;
-			e.keyCode = event.keyCode;
-			e.stateMask = event.stateMask;
-			notifyListeners(SWT.KeyDown, e);
-			break;
-		}
-		case SWT.KeyUp: {
-			Event e = new Event();
-			e.time = event.time;
-			e.character = event.character;
-			e.keyCode = event.keyCode;
-			e.stateMask = event.stateMask;
-			notifyListeners(SWT.KeyUp, e);
-			break;
-		}
-		case SWT.Modify: {
-			table.deselectAll();
-			Event e = new Event();
-			e.time = event.time;
-			notifyListeners(SWT.Modify, e);
-			break;
-		}
-		case SWT.MouseDown: {
-			if (event.button != 1) {
-				return;
-			}
-			if (text.getEditable()) {
-				return;
-			}
-			boolean dropped = isDropped();
-			text.selectAll();
-			if (!dropped) {
-				setFocus();
-			}
-			dropDown(!dropped);
-			break;
-		}
-		case SWT.MouseUp: {
-			if (event.button != 1) {
-				return;
-			}
-			if (text.getEditable()) {
-				return;
-			}
-			text.selectAll();
-			break;
-		}
-		case SWT.Traverse: {
-			switch (event.detail) {
-			case SWT.TRAVERSE_RETURN:
-			case SWT.TRAVERSE_ARROW_PREVIOUS:
-			case SWT.TRAVERSE_ARROW_NEXT:
-				// The enter causes default selection and
-				// the arrow keys are used to manipulate the list contents so
-				// do not use them for traversal.
-				event.doit = false;
-				break;
-			}
-
-			Event e = new Event();
-			e.time = event.time;
-			e.detail = event.detail;
-			e.doit = event.doit;
-			e.character = event.character;
-			e.keyCode = event.keyCode;
-			notifyListeners(SWT.Traverse, e);
-			event.doit = e.doit;
-			event.detail = e.detail;
-			break;
-		}
-		}
-	}
-
-	/**
-	 * @param defaultValue
-	 */
-	public void setDefaultValue(String defaultValue) {
-		this.defaultValue = defaultValue;
-		int index = Arrays.asList(getTableItems()).indexOf(defaultValue);
-		if (index != -1) {
-			table.getItem(index).setFont(
-					JFaceResources.getFontRegistry().getBold(
-							JFaceResources.DEFAULT_FONT));
-		}
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/UTF8Util.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/UTF8Util.java
deleted file mode 100644
index 31aac19..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/UTF8Util.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.utils;
-
-/**
- * TODO: this class doesn't seem to be in use
- * @author mengbo
- * @version 1.5
- */
-public final class UTF8Util {
-	private static final char[] HEX_DIGITS = { '0', '1', '2', '3', '4', '5',
-			'6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
-
-	/**
-	 * @param s
-	 * @return the unwound string
-	 */
-	public static String unwindEscapeChars(String s) {
-		StringBuffer sb = new StringBuffer(s.length());
-		int length = s.length();
-		for (int i = 0; i < length; i++) {
-			char c = s.charAt(i);
-			sb.append(getUnwoundString(c));
-		}
-		return sb.toString();
-	}
-
-	private static String getUnwoundString(char c) {
-		switch (c) {
-		case '\b':
-			return "\\b";//$NON-NLS-1$
-		case '\t':
-			return "\\t";//$NON-NLS-1$
-		case '\n':
-			return "\\n";//$NON-NLS-1$
-		case '\f':
-			return "\\f";//$NON-NLS-1$	
-		case '\r':
-			return "\\r";//$NON-NLS-1$
-
-			// These can be used unescaped in properties file:
-		case '\"':
-			return "\\\"";//$NON-NLS-1$
-		case '\'':
-			return "\\\'";//$NON-NLS-1$
-
-		case '\\':
-			return "\\\\";//$NON-NLS-1$
-
-		case '=':
-			return "\\=";//$NON-NLS-1$
-
-			// This is only done when writing to the .properties file in
-			// #unwindValue(String)
-			// case '!':
-			// return "\\!";//$NON-NLS-1$
-			// case '#':
-			// return "\\#";//$NON-NLS-1$
-
-		default:
-			if (((c < 0x0020) || (c > 0x007e))) {
-				return new StringBuffer().append('\\').append('u').append(
-						toHex((c >> 12) & 0xF)).append(toHex((c >> 8) & 0xF))
-						.append(toHex((c >> 4) & 0xF)).append(toHex(c & 0xF))
-						.toString();
-
-			}
-			return String.valueOf(c);
-		}
-	}
-
-	private static char toHex(int halfByte) {
-		return HEX_DIGITS[(halfByte & 0xF)];
-	}
-
-	private UTF8Util()
-	{
-		// no instantiation
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/WebrootUtil.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/WebrootUtil.java
deleted file mode 100644
index 3a99bf3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/WebrootUtil.java
+++ /dev/null
@@ -1,268 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.utils;
-
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.Set;
-
-import org.eclipse.core.resources.IContainer;
-import org.eclipse.core.resources.IFolder;
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.core.runtime.Platform;
-import org.eclipse.core.runtime.content.IContentType;
-import org.eclipse.core.runtime.content.IContentTypeManager;
-import org.eclipse.jst.jsf.common.ui.IFileFolderConstants;
-import org.eclipse.jst.jsf.common.ui.JSFUICommonPlugin;
-import org.eclipse.wst.common.componentcore.ComponentCore;
-import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
-import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
-import org.eclipse.wst.common.project.facet.core.IFacetedProject;
-import org.eclipse.wst.common.project.facet.core.IProjectFacet;
-import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
-import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
-
-/**
- * Web app utility methods
- */
-public class WebrootUtil {
-
-	/**
-	 * get the webpath for the project path. The project path is something like
-	 * "/projectname/webroot/filename.jsp", or "/projectname/webroot/folder".
-	 * The project information should be removed from project path, e.g,
-	 * "/filename.jsp" or "/folder/*";
-	 * 
-	 * @param path
-	 * @return the web path
-	 */
-	public static String getWebPath(IPath path) {
-		String strWebrootPath = ""; //$NON-NLS-1$
-		IProject project = WorkspaceUtil.getProjectFor(path);
-		IPath webContentPath = getWebContentPath(project);
-		if (webContentPath != null && webContentPath.isPrefixOf(path)) {
-			int start = path.matchingFirstSegments(webContentPath);
-			String[] segments = path.segments();
-			for (int i = start, n = path.segmentCount(); i < n; i++) {
-				strWebrootPath = strWebrootPath
-						+ IFileFolderConstants.PATH_SEPARATOR + segments[i];
-			}
-		}
-		return strWebrootPath;
-	}
-
-	/**
-	 * To see if a resource is under the webcontent folder.
-	 * 
-	 * @param resource
-	 * @return true if resource is within the web content folder hierarchy
-	 */
-	public static boolean isUnderWebContentFolder(IResource resource) {
-		IPath webContentPath = getWebContentPath(resource.getProject());
-		if (webContentPath != null) {
-			return webContentPath.isPrefixOf(resource.getFullPath());
-		}
-		return true;
-	}
-
-	/**
-	 * @param project
-	 * @return full path to web content folder
-	 */
-	public static IPath getWebContentPath(IProject project) {
-		if (project != null) {
-			IVirtualComponent component = ComponentCore.createComponent(project);
-			if (component != null) {
-				IVirtualFolder rootFolder = component.getRootFolder();
-				if (rootFolder != null) {
-					IContainer underlyingFolder = rootFolder.getUnderlyingFolder();
-					if (underlyingFolder != null) {
-						return underlyingFolder.getFullPath();
-					}
-				}
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * Return the name of the web content folder. i.e, "WebContent"
-	 * 
-	 * @param project
-	 * @return the web content folder name
-	 */
-	public static String getWebContentFolderName(IProject project) {
-		IPath webContentPath = getWebContentPath(project);
-		if (webContentPath != null)
-			return webContentPath.lastSegment();
-		return null;
-	}
-
-	/**
-	 * @param project
-	 * @return folder where for web content
-	 */
-	public static IFolder getWebContentFolder(IProject project) {
-		IPath webContentPath = getWebContentPath(project);
-		IFolder folder = null;
-		if (webContentPath != null) {
-			folder = project.getFolder(webContentPath.removeFirstSegments(1));
-		}
-		return folder;
-	}
-
-	/**
-	 * return the depth of webcontent folder. For example, if the webcontent
-	 * folder path is /projectname/webContent, then return 2, if it's
-	 * /projectname/a/webContent, then return 3.
-	 * 
-	 * @param project
-	 * @return the depth of webcontent folder
-	 */
-	public static int getWebContentFolderDepth(IProject project) {
-		if (project != null) {
-			IPath webContentPath = getWebContentPath(project);
-			if (webContentPath != null) {
-				return webContentPath.segmentCount();
-			}
-		}
-		// default to 2
-		return 2;
-	}
-
-	/**
-	 * determine the path of web file is valid or not
-	 * 
-	 * @param path -
-	 *            the path of web file
-	 * @return - true - valid web file
-	 */
-	public static boolean isValidWebFile(IPath path) {
-		String[] jspExtensions = getJSPFileExtensions();
-
-		String extension = path.getFileExtension();
-		if (extension != null
-				&& Arrays.asList(jspExtensions).contains(extension))
-		{
-				return true;
-		}
-
-		return false;
-	}
-
-	/**
-	 * get the webpath for the project path. The project path is something like
-	 * "/projectname/webroot/filename.jsp", or "/projectname/webroot/folder".
-	 * The project information should be removed from project path, e.g,
-	 * "/filename.jsp" or "/folder/*";
-	 * 
-	 * @param strPath -
-	 *            the project path
-	 * @return - web path remove from "/projectname/webroot"
-	 * @deprecated use getWebPath(IPath path) instead.
-	 */
-	public static String getWebPath(String strPath) {
-		String strWebrootPath = ""; //$NON-NLS-1$
-		if (strPath != null) {
-			IPath path = new Path(strPath);
-			return getWebPath(path);
-		}
-		return strWebrootPath;
-	}
-
-	/**
-	 * @param strWebPath
-	 * @return the page name
-	 */
-	public static String getPageNameFromWebPath(String strWebPath) {
-		String pageName = strWebPath;
-
-		if (pageName.startsWith(IFileFolderConstants.PATH_SEPARATOR)) {
-			pageName = pageName.substring(1);
-		}
-
-		String[] jspExtensions = getJSPFileExtensions();
-		for (int i = 0, n = jspExtensions.length; i < n; i++) {
-			String extension = IFileFolderConstants.DOT + jspExtensions[i];
-			if (pageName.endsWith(extension)) {
-			pageName = pageName.substring(0, pageName.length()
-						- extension.length());
-				break;
-		}
-		}
-
-		return pageName;
-	}
-	/**
-	 * Get the JSP file extension from Eclipse preference
-	 * Windows->Preferences->General->Content Types
-	 * 
-	 * @return String Array for JSP file extensions
-	 */
-	public static String[] getJSPFileExtensions() {
-		IContentTypeManager typeManager = Platform.getContentTypeManager();
-		IContentType jspContentType = typeManager
-				.getContentType("org.eclipse.jst.jsp.core.jspsource"); //$NON-NLS-1$
-		if (jspContentType != null) {
-			return jspContentType
-					.getFileSpecs(IContentType.FILE_EXTENSION_SPEC);
-		}
-		return null;
-	}
-
-	/**
-	 * Tests if the passed IProject instance is a valid JSF project in the
-	 * following ways:
-	 * <ul>
-	 * <li>project is not null and is accessible, </li>
-	 * <li>project has the "jst.web" facet set on it.</li> 
-	 * </ul>
-	 * 
-	 * @param project
-	 *            IProject instance to be tested.
-	 * @return true if the IProject instance is a valid JSF project, else false.
-	 */
-	public static boolean isValidWebProject(IProject project) {
-		boolean isValid = false;
-		// check for null or inaccessible project
-		if (project != null && project.isAccessible()) {
-            // TODO: this was jst.jsf before, but we are checking for jst.web
-            // the javadoc seems out of sync with the method name
-			// check for "jst.web" facet on project
-			try {
-				IFacetedProject facetedProject = ProjectFacetsManager
-						.create(project);
-				if (facetedProject != null) {
-					Set projectFacets = facetedProject.getProjectFacets();
-					Iterator itProjectFacets = projectFacets.iterator();
-					while (itProjectFacets.hasNext()) {
-						IProjectFacetVersion projectFacetVersion = (IProjectFacetVersion) itProjectFacets
-								.next();
-						IProjectFacet projectFacet = projectFacetVersion
-								.getProjectFacet();
-						if ("jst.web".equals(projectFacet.getId())) { //$NON-NLS-1$
-							isValid = true;
-							break;
-						}
-					}
-				}
-			} catch (CoreException ce) {
-                JSFUICommonPlugin.getLogger(WebrootUtil.class).error("checking web project", ce); //$NON-NLS-1$
-			}
-		}
-		return isValid;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/WorkspaceUtil.java b/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/WorkspaceUtil.java
deleted file mode 100644
index 6c5dcba..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.common.ui/src/org/eclipse/jst/jsf/common/ui/internal/utils/WorkspaceUtil.java
+++ /dev/null
@@ -1,283 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.common.ui.internal.utils;
-
-import java.io.ByteArrayInputStream;
-import java.io.File;
-import java.io.InputStream;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IFolder;
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.resources.IWorkspaceRunnable;
-import org.eclipse.core.resources.ResourcesPlugin;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.core.runtime.NullProgressMonitor;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.jst.jsf.common.ui.IFileFolderConstants;
-import org.eclipse.jst.jsf.common.ui.JSFUICommonPlugin;
-import org.eclipse.jst.jsf.common.ui.internal.logging.Logger;
-
-/**
- * TODO: This class should be abstract to common utility.
- * 
- * This class implements management of resource in a workspace.
- */
-public final class WorkspaceUtil {
-	/** log instance */
-	private static final Logger log = JSFUICommonPlugin
-			.getLogger(WorkspaceUtil.class);
-
-	private WorkspaceUtil() {
-	    // no external instantiation
-	}
-
-	/**
-	 * Create the given file in the workspace resource info tree.
-	 * @param resource 
-	 * @param contents 
-	 */
-	public static void ensureExistsInWorkspace(final IFile resource,
-			final InputStream contents) {
-		if (resource == null) {
-			return;
-		}
-		IWorkspaceRunnable body = new IWorkspaceRunnable() {
-			public void run(IProgressMonitor monitor) throws CoreException {
-				if (resource.exists()) {
-					resource.setContents(contents, true, false, null);
-				} else {
-					ensureExistsInWorkspace(resource.getParent(), true);
-					resource.create(contents, true, null);
-				}
-			}
-		};
-		try {
-			ResourcesPlugin.getWorkspace().run(body, null);
-		} catch (CoreException e) {
-			// Test.EclipseWorkspaceTest.Error.FileCreationInWorkspace = Fail in
-			// creating file:{0} in the workspace resource info tree.
-			log
-					.error(
-							"Test.EclipseWorkspaceTest.Error.FileCreationInWorkspace", resource.getName(), e);//$NON-NLS-1$
-		}
-	}
-
-	/**
-	 * Create the given file in the workspace resource info tree.
-	 * @param resource 
-	 * @param contents 
-	 */
-	public static void ensureExistsInWorkspace(IFile resource, String contents) {
-		// FIXME: We'll need some way for handing file encoding.
-		ensureExistsInWorkspace(resource, new ByteArrayInputStream(contents
-				.getBytes()));
-	}
-
-	/**
-	 * Create the given resource in the workspace resource info tree.
-	 * @param resource 
-	 * @param local 
-	 */
-	public static void ensureExistsInWorkspace(final IResource resource,
-			final boolean local) {
-		IWorkspaceRunnable body = new IWorkspaceRunnable() {
-			public void run(IProgressMonitor monitor) throws CoreException {
-				create(resource, local);
-			}
-		};
-		try {
-			ResourcesPlugin.getWorkspace().run(body, null);
-		} catch (CoreException e) {
-			// Test.EclipseWorkspaceTest.Error.ResourceCreationInWorkspace =
-			// Fail in creating resource:{0} in the workspace resource info
-			// tree.
-			log
-					.error(
-							"Test.EclipseWorkspaceTest.Error.ResourceCreationInWorkspace", resource.getName(), e);//$NON-NLS-1$
-		}
-	}
-
-	/**
-	 * crate the resource if the resource is not existed, create a new one.
-	 * 
-	 * @param resource -
-	 *            resource instance
-	 * @param local -
-	 *            a flag controlling whether or not the folder will be local
-	 *            after the creation
-	 * @throws CoreException
-	 */
-	protected static void create(final IResource resource, boolean local)
-			throws CoreException {
-		if (resource == null || resource.exists()) {
-			return;
-		}
-		if (!resource.getParent().exists()) {
-			create(resource.getParent(), local);
-		}
-		switch (resource.getType()) {
-		case IResource.FILE:
-			((IFile) resource).create(local ? new ByteArrayInputStream(
-					new byte[0]) : null, true, getMonitor());
-			break;
-		case IResource.FOLDER:
-			((IFolder) resource).create(true, local, getMonitor());
-			break;
-		case IResource.PROJECT:
-			((IProject) resource).create(getMonitor());
-			((IProject) resource).open(getMonitor());
-			break;
-		}
-	}
-
-	/**
-	 * create and return a NullProgressMonitor
-	 * 
-	 * @return - NullProgressMonitor
-	 */
-	public static IProgressMonitor getMonitor() {
-		return new NullProgressMonitor();
-	}
-
-	/**
-	 * Get the project reference for a given path
-	 * 
-	 * @param path -
-	 *            the path
-	 * @return IProject - the project reference
-	 */
-	public static IProject getProjectFor(IPath path) {
-		String[] segs = path.segments();
-		String projectPath = new String();
-		IProject[] projects = ResourcesPlugin.getWorkspace().getRoot()
-				.getProjects();
-		IProject project = null;
-		for (int p = 0; p < projects.length; p++) {
-			if (projects[p].isOpen()) {
-				for (int s = 0; s < segs.length; s++) {
-					if (segs[s].equalsIgnoreCase(projects[p].getName())) {
-						// Once we have a match on the project name, then
-						// the remainder of the segments equals the project path
-						for (int s2 = s + 1; s2 < segs.length; s2++) {
-							projectPath = projectPath
-									+ IFileFolderConstants.PATH_SEPARATOR
-									+ segs[s2];
-						}
-						project = projects[p];
-						break;
-					}
-				}
-			}
-		}
-		if (project == null) {
-			return null;
-		}
-
-		// TODO: still don't understand why this refreshLocal is necessary
-		// for now, going to only allow it if this method is called 
-		// when the tree isn't locked.  This shouldn't cause a regression, since
-		// when the call fails currently things keep on going due to the catch
-		if (!project.getWorkspace().isTreeLocked())
-		{
-    		try {
-    			project.refreshLocal(IResource.DEPTH_INFINITE, null);
-    		} catch (CoreException e) {
-                // TODO C.B.:pushing this down to a warning because it creates really
-                // spurious output.  Don't know why we are calling refreshLocal at all.
-                JSFUICommonPlugin.getLogger(WorkspaceUtil.class).info("Error.RefreshingLocal", e); //$NON-NLS-1$
-    		}
-		}
-		
-		IResource res = project.findMember(new Path(projectPath));
-		if ((res != null) && (res.exists())) {
-			return project;
-		}
-		return null;
-	}
-
-	/**
-	 * Get the project reference for a given file
-	 * 
-	 * @param file -
-	 *            the IFile file reference
-	 * @return IProject - the project reference
-	 */
-	public static IProject getProjectFor(IFile file) {
-		IPath testPath = new Path(file.getFullPath().toOSString());
-		return getProjectFor(testPath);
-	}
-
-	/**
-	 * Get the project reference for a given file
-	 * 
-	 * @param file -
-	 *            the File file reference
-	 * @return IProject - the project reference
-	 */
-	public static IProject getProjectFor(File file) {
-		IPath testPath = new Path(file.getAbsolutePath());
-		return getProjectFor(testPath);
-	}
-
-	/**
-	 * Get the project-relative resource reference for a given path
-	 * 
-	 * @param path -
-	 *            the path
-	 * @return IResource - the project-relative resource
-	 */
-	public static IResource getProjectRelativeResource(IPath path) {
-		String[] segs = path.segments();
-		String projectPath = new String();
-		IProject[] projects = ResourcesPlugin.getWorkspace().getRoot()
-				.getProjects();
-		IProject project = null;
-		for (int p = 0; p < projects.length; p++) {
-			if (projects[p].isOpen()) {
-				for (int s = 0; s < segs.length; s++) {
-					if (segs[s].equalsIgnoreCase(projects[p].getName())) {
-						// Once we have a match on the project name, then
-						// the remainder of the segments equals the project path
-						for (int s2 = s + 1; s2 < segs.length; s2++) {
-							projectPath = projectPath
-									+ IFileFolderConstants.PATH_SEPARATOR
-									+ segs[s2];
-						}
-						project = projects[p];
-						break;
-					}
-				}
-			}
-		}
-		if (project == null) {
-			return null;
-		}
-
-		return project.getFile(projectPath);
-	}
-
-	/**
-	 * Get the project-relative resource reference for a given file
-	 * 
-	 * @param file -
-	 *            the File file reference
-	 * @return IResource - the project-relative resource
-	 */
-	public static IResource getProjectRelativeResource(File file) {
-		IPath testPath = new Path(file.getAbsolutePath());
-		return getProjectRelativeResource(testPath);
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/.classpath b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/.classpath
deleted file mode 100644
index 304e861..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/.classpath
+++ /dev/null
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
-	<classpathentry kind="output" path="bin"/>
-</classpath>
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/.project b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/.project
deleted file mode 100644
index c7247f3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/.project
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jst.jsf.facelet.ui</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/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/.settings/org.eclipse.jdt.core.prefs b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/.settings/org.eclipse.jdt.core.prefs
deleted file mode 100644
index 42536dd..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/.settings/org.eclipse.jdt.core.prefs
+++ /dev/null
@@ -1,79 +0,0 @@
-#Tue Oct 23 12:04:38 PDT 2007
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
-org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.5
-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.doc.comment.support=enabled
-org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.autoboxing=warning
-org.eclipse.jdt.core.compiler.problem.deprecation=warning
-org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
-org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
-org.eclipse.jdt.core.compiler.problem.discouragedReference=ignore
-org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore
-org.eclipse.jdt.core.compiler.problem.fatalOptionalError=enabled
-org.eclipse.jdt.core.compiler.problem.fieldHiding=warning
-org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
-org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
-org.eclipse.jdt.core.compiler.problem.forbiddenReference=error
-org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
-org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
-org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=warning
-org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
-org.eclipse.jdt.core.compiler.problem.invalidJavadoc=error
-org.eclipse.jdt.core.compiler.problem.invalidJavadocTags=enabled
-org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef=disabled
-org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef=disabled
-org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=protected
-org.eclipse.jdt.core.compiler.problem.localVariableHiding=warning
-org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
-org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingJavadocComments=warning
-org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=protected
-org.eclipse.jdt.core.compiler.problem.missingJavadocTags=warning
-org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=protected
-org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning
-org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
-org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
-org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore
-org.eclipse.jdt.core.compiler.problem.nullReference=ignore
-org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
-org.eclipse.jdt.core.compiler.problem.parameterAssignment=ignore
-org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=warning
-org.eclipse.jdt.core.compiler.problem.potentialNullReference=ignore
-org.eclipse.jdt.core.compiler.problem.rawTypeReference=ignore
-org.eclipse.jdt.core.compiler.problem.redundantNullCheck=ignore
-org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
-org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
-org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled
-org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
-org.eclipse.jdt.core.compiler.problem.typeParameterHiding=ignore
-org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=ignore
-org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=error
-org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning
-org.eclipse.jdt.core.compiler.problem.unnecessaryElse=warning
-org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=warning
-org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=warning
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference=enabled
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.unusedImport=error
-org.eclipse.jdt.core.compiler.problem.unusedLabel=warning
-org.eclipse.jdt.core.compiler.problem.unusedLocal=error
-org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
-org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference=enabled
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
-org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=error
-org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.compiler.source=1.5
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/.settings/org.eclipse.pde.prefs b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/.settings/org.eclipse.pde.prefs
deleted file mode 100644
index cde2584..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/.settings/org.eclipse.pde.prefs
+++ /dev/null
@@ -1,24 +0,0 @@
-#Fri May 30 12:03:18 PDT 2008
-compilers.f.unresolved-features=1
-compilers.f.unresolved-plugins=1
-compilers.incompatible-environment=1
-compilers.p.build=1
-compilers.p.deprecated=1
-compilers.p.discouraged-class=2
-compilers.p.internal=1
-compilers.p.missing-bundle-classpath-entries=1
-compilers.p.missing-packages=0
-compilers.p.no-required-att=0
-compilers.p.not-externalized-att=0
-compilers.p.unknown-attribute=1
-compilers.p.unknown-class=1
-compilers.p.unknown-element=1
-compilers.p.unknown-identifier=1
-compilers.p.unknown-resource=1
-compilers.p.unresolved-ex-points=0
-compilers.p.unresolved-import=0
-compilers.s.create-docs=false
-compilers.s.doc-folder=doc
-compilers.s.open-tags=1
-compilers.use-project=true
-eclipse.preferences.version=1
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/META-INF/MANIFEST.MF b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/META-INF/MANIFEST.MF
deleted file mode 100644
index ee38934..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,40 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: %Bundle-Name.0
-Bundle-SymbolicName: org.eclipse.jst.jsf.facelet.ui;singleton:=true
-Bundle-Version: 1.0.1.qualifier
-Bundle-Activator: org.eclipse.jst.jsf.facelet.ui.internal.FaceletUiPlugin
-Bundle-Localization: plugin
-Require-Bundle: org.eclipse.ui,
- org.eclipse.core.runtime,
- org.eclipse.wst.html.core;bundle-version="1.1.200",
- org.eclipse.wst.html.ui;bundle-version="1.0.300",
- org.eclipse.wst.xml.ui;bundle-version="1.0.400",
- org.eclipse.jface.text;bundle-version="3.4.0",
- org.eclipse.wst.sse.ui;bundle-version="[1.1.0,1.4.0)",
- org.eclipse.wst.sse.core;bundle-version="1.1.300",
- org.eclipse.wst.xml.core;bundle-version="1.1.300",
- org.eclipse.jst.jsf.common;bundle-version="1.0.1",
- org.eclipse.core.resources;bundle-version="3.4.0",
- org.eclipse.jst.jsf.core;bundle-version="1.0.1",
- org.eclipse.jst.jsf.common.runtime;bundle-version="1.0.0",
- org.eclipse.wst.validation;bundle-version="1.1.103",
- org.eclipse.emf.common;bundle-version="2.4.0",
- org.eclipse.wst.common.project.facet.ui,
- org.eclipse.wst.common.frameworks;bundle-version="1.1.102",
- org.eclipse.core.databinding;bundle-version="1.1.0",
- org.eclipse.jface.databinding;bundle-version="1.2.0",
- org.eclipse.wst.common.modulecore;bundle-version="1.1.103",
- org.eclipse.core.databinding.beans;bundle-version="1.0.100",
- org.eclipse.wst.common.frameworks.ui;bundle-version="1.1.101",
- org.eclipse.jst.jsf.ui;bundle-version="1.0.1",
- org.eclipse.jst.jsf.facelet.core;bundle-version="1.0.0"
-Bundle-ActivationPolicy: lazy
-Bundle-RequiredExecutionEnvironment: J2SE-1.5
-Export-Package: org.eclipse.jst.jsf.facelet.ui.internal;x-internal:=true,
- org.eclipse.jst.jsf.facelet.ui.internal.contentassist;x-internal:=true,
- org.eclipse.jst.jsf.facelet.ui.internal.facet;x-internal:=true,
- org.eclipse.jst.jsf.facelet.ui.internal.hover;x-internal:=true,
- org.eclipse.jst.jsf.facelet.ui.internal.htmleditor;x-internal:=true,
- org.eclipse.jst.jsf.facelet.ui.internal.validation;x-internal:=true
-Bundle-Vendor: %Bundle-Vendor.0
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/about.html b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/about.html
deleted file mode 100644
index 90bd74d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/about.html
+++ /dev/null
@@ -1,22 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<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>June, 2008</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 1.0 (&quot;EPL&quot;).  A copy of the EPL is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</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.</p>
-
-</body>
-</html>
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/build.properties b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/build.properties
deleted file mode 100644
index 28e0ea2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/build.properties
+++ /dev/null
@@ -1,8 +0,0 @@
-source.. = src/
-output.. = bin/
-bin.includes = META-INF/,\
-               .,\
-               plugin.xml,\
-               plugin.properties,\
-               templates/,\
-               about.html
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/plugin.properties b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/plugin.properties
deleted file mode 100644
index 21fb12e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/plugin.properties
+++ /dev/null
@@ -1,5 +0,0 @@
-FaceletHTMLValidator_name=Facelet HTML Validator
-EL_Hyperlinkdetector_name=Facelet EL Hyperlink Detector
-FaceletValidatorMarker=Facelet Validator
-Bundle-Name.0 = UI Plug-in
-Bundle-Vendor.0 = Eclipse.org
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/plugin.xml b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/plugin.xml
deleted file mode 100644
index d2dab59..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/plugin.xml
+++ /dev/null
@@ -1,147 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?eclipse version="3.2"?>
-<plugin>
-   <extension
-         point="org.eclipse.wst.sse.ui.editorConfiguration">
-      <sourceViewerConfiguration
-            class="org.eclipse.wst.html.ui.StructuredTextViewerConfigurationHTML"
-            target="org.eclipse.wst.html.core.htmlsource">
-      </sourceViewerConfiguration>
-      <provisionalConfiguration
-            class="org.eclipse.jst.jsf.facelet.ui.internal.contentassist.XHTMLContentAssistProcessor"
-            target="org.eclipse.wst.html.HTML_DEFAULT"
-            type="contentassistprocessor">
-      </provisionalConfiguration>
-     <provisionalConfiguration 
-        type="contentassistprocessor" 
-        class="org.eclipse.jst.jsf.facelet.ui.internal.contentassist.CompositeAttributeAssistProcessor" 
-        target="org.eclipse.wst.html.HTML_DEFAULT" />
-      <documentationTextHover
-          class="org.eclipse.jst.jsf.facelet.ui.internal.hover.FaceletHover"
-          target="org.eclipse.wst.html.HTML_DEFAULT">
-    </documentationTextHover>
-    </extension>
-
-    <extension point="org.eclipse.ui.workbench.texteditor.hyperlinkDetectors">
-       <hyperlinkDetector
-             class="org.eclipse.jst.jsf.facelet.ui.internal.htmleditor.FaceletELHyperlinkDetector"
-             id="org.eclipse.jst.jsf.ui.elhyperlinkdetector"
-             name="%EL_Hyperlinkdetector_name"
-             targetId="org.eclipse.wst.html.core.htmlsource">
-       </hyperlinkDetector>
-    </extension>
-
-   <extension
-        id="FaceletValidationMarker"
-        name="%FaceletValidatorMarker"
-        point="org.eclipse.core.resources.markers">
-      <super
-            type="org.eclipse.wst.validation.problemmarker">
-      </super>
-    </extension>
-
-   <extension
-        point="org.eclipse.wst.validation.validatorV2"
-        id="FaceletHTMLValidator"
-        name="%FaceletHTMLValidator_name">
-        <validator
-            build="true"
-            class="org.eclipse.jst.jsf.facelet.ui.internal.validation.HTMLValidator"
-            manual="true"
-            markerId="org.eclipse.jst.jsf.facelet.ui.FaceletValidationMarker"
-            version="1">
-
-         <include>
-            <rules>
-               <projectNature
-                     id="org.eclipse.wst.common.modulecore.ModuleCoreNature">
-               </projectNature>
-            </rules>
-         </include>
-         <include>
-            <rules>
-               <projectNature
-                     id="org.eclipse.jdt.core.javanature">
-               </projectNature>
-            </rules>
-         </include>
-
-         <include>
-            <rules>
-               <facet
-                     id="jst.java">
-               </facet>
-            </rules>
-         </include>
-         <include>
-            <rules>
-               <facet
-                     id="jst.web">
-               </facet>
-            </rules>
-         </include>
-         <include>
-            <rules>
-               <facet
-                     id="jst.jsf" version="2.0">
-               </facet>
-            </rules>
-         </include>
-         <include>
-            <rules>
-               <contentType
-                     exactMatch="false"
-                     id="jsf.facelet">
-               </contentType>
-               <contentType
-                     exactMatch="false"
-                     id="jsf.facelet.composite">
-               </contentType>
-            </rules>
-         </include>
-         <group
-               id="org.eclipse.wst.sse.core.structuredModelGroup">
-         </group>
-
-        </validator>
-        </extension>
-        
-       <!--<extension
-        point="org.eclipse.wst.validation.validator"
-        id="FaceletTaglibValidator"
-        name="%FaceletTaglibValidator">
-        <validator>
-            <projectNature id="org.eclipse.wst.common.modulecore.ModuleCoreNature" />
-            <projectNature id="org.eclipse.jdt.core.javanature" />
-            <filter
-                objectClass="org.eclipse.core.resources.IFile"
-                nameFilter="faces-config.xml">
-            </filter>
-            <markerId
-               markerIdValue="JSPSemanticsValidatorMarker">
-            </markerId>
-            <helper 
-                class="org.eclipse.wst.validation.internal.operations.WorkbenchContext">
-            </helper>
-            <run
-                class="org.eclipse.jst.jsf.validation.internal.appconfig.AppConfigValidator"
-                incremental="true"
-                fullBuild="true"
-            />
-        </validator>
-    </extension>-->
-   <extension
-         point="org.eclipse.ui.editors.templates">
-      <include
-            file="templates/templates.xml"
-            translations="$nl$/templates/templates.properties">
-      </include>
-   </extension>
-   <!--<extension
-         point="org.eclipse.wst.xml.core.modelQueryExtensions">
-      <modelQueryExtension
-            class="org.eclipse.jst.jsf.facelet.ui.internal.contentassist.MyModelQueryExtension"
-            contentType="org.eclipse.wst.html.core.htmlsource">
-      </modelQueryExtension>
-   </extension>-->
-</plugin>
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/FaceletUiPlugin.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/FaceletUiPlugin.java
deleted file mode 100644
index 15ed671..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/FaceletUiPlugin.java
+++ /dev/null
@@ -1,69 +0,0 @@
-package org.eclipse.jst.jsf.facelet.ui.internal;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-import org.eclipse.jst.jsf.designtime.internal.view.model.TagRegistryFactory.TagRegistryFactoryException;
-import org.eclipse.ui.plugin.AbstractUIPlugin;
-import org.osgi.framework.BundleContext;
-
-/**
- * The activator class controls the plug-in life cycle
- */
-public class FaceletUiPlugin extends AbstractUIPlugin
-{
-
-    /**
-     * The plug-in ID
-     */
-    public static final String     PLUGIN_ID = "org.eclipse.jst.jsf.facelet.ui";
-
-    // The shared instance
-    private static FaceletUiPlugin plugin;
-
-    /*
-     * (non-Javadoc)
-     * 
-     * @see
-     * org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext
-     * )
-     */
-    @Override
-    public void start(final BundleContext context) throws Exception
-    {
-        super.start(context);
-        plugin = this;
-    }
-
-    /*
-     * (non-Javadoc)
-     * 
-     * @see
-     * org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext
-     * )
-     */
-    @Override
-    public void stop(final BundleContext context) throws Exception
-    {
-        plugin = null;
-        super.stop(context);
-    }
-
-    /**
-     * Returns the shared instance
-     * 
-     * @return the shared instance
-     */
-    public static FaceletUiPlugin getDefault()
-    {
-        return plugin;
-    }
-
-    /**
-     * @param e
-     */
-    public static void log(final TagRegistryFactoryException e)
-    {
-        getDefault().getLog().log(new Status(IStatus.ERROR, PLUGIN_ID, "", e));
-    }
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/contentassist/CompositeAttributeAssistProcessor.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/contentassist/CompositeAttributeAssistProcessor.java
deleted file mode 100644
index 13312fa..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/contentassist/CompositeAttributeAssistProcessor.java
+++ /dev/null
@@ -1,123 +0,0 @@
-package org.eclipse.jst.jsf.facelet.ui.internal.contentassist;
-
-import org.eclipse.jface.text.ITextViewer;
-import org.eclipse.jface.text.contentassist.ICompletionProposal;
-import org.eclipse.jface.text.contentassist.IContentAssistProcessor;
-import org.eclipse.jface.text.contentassist.IContextInformation;
-import org.eclipse.jface.text.contentassist.IContextInformationValidator;
-import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContext;
-import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContextFactory;
-import org.eclipse.jst.jsf.designtime.DTAppManagerUtil;
-import org.eclipse.jst.jsf.designtime.internal.view.XMLViewDefnAdapter;
-import org.eclipse.jst.jsf.designtime.internal.view.IDTViewHandler.ViewHandlerException;
-import org.eclipse.jst.jsf.designtime.internal.view.XMLViewDefnAdapter.DTELExpression;
-import org.eclipse.jst.jsf.ui.internal.contentassist.JSFContentAssistProcessor;
-import org.eclipse.jst.jsf.ui.internal.contentassist.el.JSFELContentAssistProcessor;
-
-/**
- * Composes the EL and non-EL attribute value assist processor for JSF.  This
- * is necessary mainly because, without the EL partitioning in HTML, both
- * processors would otherwise activate on every attribute.
- * 
- * @author cbateman
- *
- */
-public class CompositeAttributeAssistProcessor implements
-        IContentAssistProcessor
-{
-    private JSFContentAssistProcessor _nonELProcessor;
-    private JSFELContentAssistProcessor _elProcessor;
-    private char[]                      _activationChars;
-
-    /**
-     * Default constructor
-     */
-    public CompositeAttributeAssistProcessor()
-    {
-        _nonELProcessor = new JSFContentAssistProcessor();
-        _elProcessor = new JSFELContentAssistProcessor();
-        
-        char[] nonELChars = 
-            _nonELProcessor.getCompletionProposalAutoActivationCharacters();
-        char[] elChars =
-            _elProcessor.getCompletionProposalAutoActivationCharacters();
-        _activationChars = new char[nonELChars.length+elChars.length];
-        System.arraycopy(nonELChars, 0, _activationChars, 0, nonELChars.length);
-        System.arraycopy(elChars, 0, _activationChars, nonELChars.length, elChars.length);
-        
-        
-    }
-    public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer,
-            int offset)
-    {
-        if (isEL(viewer, offset))
-        {
-            return _elProcessor.computeCompletionProposals(viewer, offset);
-        }
-        return _nonELProcessor.computeCompletionProposals(viewer, offset);
-    }
-
-    public IContextInformation[] computeContextInformation(ITextViewer viewer,
-            int offset)
-    {
-        if (isEL(viewer, offset))
-        {
-            return _elProcessor.computeContextInformation(viewer, offset);
-        }
-        return _nonELProcessor.computeContextInformation(viewer, offset);
-    }
-
-    public char[] getCompletionProposalAutoActivationCharacters()
-    {
-        return _activationChars;
-    }
-
-    public char[] getContextInformationAutoActivationCharacters()
-    {
-        // disable this functionality
-        return null;
-    }
-
-    public IContextInformationValidator getContextInformationValidator()
-    {
-        // disable this functionality
-        return null;
-    }
-
-    public String getErrorMessage()
-    {
-        // TODO Auto-generated method stub
-        return null;
-    }
-
-    private boolean isEL(final ITextViewer viewer, int offset)
-    {
-        IStructuredDocumentContext context =
-            IStructuredDocumentContextFactory.INSTANCE.getContext(viewer, offset);
-        
-        if (context != null)
-        {
-            XMLViewDefnAdapter adapter = 
-                DTAppManagerUtil.getXMLViewDefnAdapter(context);
-            if (adapter != null)
-            {
-                try
-                {
-                    DTELExpression elExpression = adapter.getELExpression(context);
-    
-                    // only return true if we definitively find EL
-                    if(elExpression != null)
-                    {
-                        return true;
-                    }
-                }
-                catch (ViewHandlerException e)
-                {
-                    // fall through to false, no el
-                }
-            }
-        }
-        // all other cases, return false
-        return false;
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/contentassist/MyModelQueryExtension.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/contentassist/MyModelQueryExtension.java
deleted file mode 100644
index f2b80aa..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/contentassist/MyModelQueryExtension.java
+++ /dev/null
@@ -1,84 +0,0 @@
-package org.eclipse.jst.jsf.facelet.ui.internal.contentassist;
-
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.jst.jsf.context.resolver.structureddocument.IStructuredDocumentContextResolverFactory;
-import org.eclipse.jst.jsf.context.resolver.structureddocument.IWorkspaceContextResolver;
-import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContext;
-import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContextFactory2;
-import org.eclipse.jst.jsf.facelet.core.internal.cm.FaceletDocumentFactory;
-import org.eclipse.jst.jsf.facelet.core.internal.util.ViewUtil;
-import org.eclipse.jst.jsf.facelet.core.internal.util.ViewUtil.PrefixEntry;
-import org.eclipse.wst.xml.core.internal.contentmodel.CMDocument;
-import org.eclipse.wst.xml.core.internal.contentmodel.CMNode;
-import org.eclipse.wst.xml.core.internal.contentmodel.modelquery.extension.ModelQueryExtension;
-import org.w3c.dom.Element;
-
-/**
- * A model query extension used to help support content assist in html files.
- * 
- * @author cbateman
- *
- */
-public class MyModelQueryExtension extends ModelQueryExtension
-{
-
-    @Override
-    public String[] getAttributeValues(Element ownerElement, String namespace,
-            String name)
-    {
-        // TODO Auto-generated method stub
-        return super.getAttributeValues(ownerElement, namespace, name);
-    }
-
-    @Override
-    public CMNode[] getAvailableElementContent(Element parentElement,
-            String namespace, int includeOptions)
-    {
-        final IStructuredDocumentContext context = IStructuredDocumentContextFactory2.INSTANCE
-                .getContext(parentElement);
-        if (context != null)
-        {
-            final IWorkspaceContextResolver resolver = IStructuredDocumentContextResolverFactory.INSTANCE
-                    .getWorkspaceContextResolver(context);
-            
-            if (resolver != null)
-            {
-                final IProject project = resolver.getProject();
-                final FaceletDocumentFactory factory = 
-                    new FaceletDocumentFactory(project);
-                final Map<String, PrefixEntry> map = 
-                    ViewUtil.getDocumentNamespaces(parentElement.getOwnerDocument());
-                String prefix = null;
-                for (final Map.Entry<String, PrefixEntry> entry : map.entrySet())
-                {
-                    if (entry.getValue().getUri().equals(namespace))
-                    {
-                        prefix = entry.getValue().getPrefix();
-                        break;
-                    }
-                }
-                
-                if (prefix != null)
-                {
-                    CMDocument document = 
-                        factory.createCMDocumentForContext(namespace, prefix);
-                    if (document != null)
-                    {
-                        List<CMNode>  nodes = new ArrayList<CMNode>();
-                        for (final Iterator<?> it = document.getElements().iterator(); it.hasNext();)
-                        {
-                            nodes.add((CMNode)it.next());
-                        }
-                        return nodes.toArray(new CMNode[0]);
-                    }
-                }
-            }
-        }
-        return new CMNode[0];
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/contentassist/XHTMLContentAssistProcessor.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/contentassist/XHTMLContentAssistProcessor.java
deleted file mode 100644
index 0b2afd4..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/contentassist/XHTMLContentAssistProcessor.java
+++ /dev/null
@@ -1,277 +0,0 @@
-package org.eclipse.jst.jsf.facelet.ui.internal.contentassist;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.jface.text.ITextViewer;
-import org.eclipse.jface.text.contentassist.ICompletionProposal;
-import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.Namespace;
-import org.eclipse.jst.jsf.context.resolver.structureddocument.IDOMContextResolver;
-import org.eclipse.jst.jsf.context.resolver.structureddocument.IStructuredDocumentContextResolverFactory;
-import org.eclipse.jst.jsf.context.resolver.structureddocument.IWorkspaceContextResolver;
-import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContext;
-import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContextFactory;
-import org.eclipse.jst.jsf.designtime.internal.view.model.ITagRegistry;
-import org.eclipse.jst.jsf.facelet.core.internal.cm.FaceletDocumentFactory;
-import org.eclipse.jst.jsf.facelet.core.internal.util.ViewUtil;
-import org.eclipse.jst.jsf.facelet.core.internal.util.ViewUtil.PrefixEntry;
-import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
-import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion;
-import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegionList;
-import org.eclipse.wst.sse.ui.internal.contentassist.CustomCompletionProposal;
-import org.eclipse.wst.xml.core.internal.contentmodel.CMDocument;
-import org.eclipse.wst.xml.core.internal.contentmodel.CMElementDeclaration;
-import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
-import org.eclipse.wst.xml.core.internal.regions.DOMRegionContext;
-import org.eclipse.wst.xml.ui.internal.contentassist.AbstractContentAssistProcessor;
-import org.eclipse.wst.xml.ui.internal.contentassist.ContentAssistRequest;
-import org.eclipse.wst.xml.ui.internal.contentassist.XMLRelevanceConstants;
-import org.w3c.dom.Attr;
-import org.w3c.dom.Document;
-import org.w3c.dom.Element;
-import org.w3c.dom.NamedNodeMap;
-import org.w3c.dom.Node;
-
-/**
- * The main entry point for Facelet content assist in html files.
- * @author cbateman
- *
- */
-public class XHTMLContentAssistProcessor extends AbstractContentAssistProcessor
-{
-    private IFile _file;
-    private FaceletDocumentFactory      _factory;
-
-    private final static ICompletionProposal[] NO_PROPOSALS = new ICompletionProposal[0];
-    
-    @Override
-    public ICompletionProposal[] computeCompletionProposals(
-            final ITextViewer textViewer, final int documentPosition)
-    {
-        ICompletionProposal[] proposals = null;
-        _file = getFile(textViewer, documentPosition);
-
-        if (_file != null && shouldContribute(_file))
-        {
-            _factory = new FaceletDocumentFactory(_file.getProject());
-            proposals =  super.computeCompletionProposals(textViewer,
-                    documentPosition);
-        }
-        return proposals != null ? proposals : NO_PROPOSALS;
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    protected List getAvailableChildElementDeclarations(final Element parent,
-            final int childPosition, final int kindOfAction)
-    {
-        final Map<String, PrefixEntry> namespaces = getDocumentNamespaces(
-                _factory, childPosition);
-        final List availableChildElements = new ArrayList();
-
-        for (final Map.Entry<String, PrefixEntry> entry : namespaces.entrySet())
-        {
-            final String prefix = entry.getValue().getPrefix();
-            final CMDocument cmDocument = _factory.createCMDocumentForContext(
-                    entry.getValue().getUri(), prefix);
-
-            if (cmDocument != null)
-            {
-                final Iterator it = cmDocument.getElements().iterator();
-                while (it.hasNext())
-                {
-                    availableChildElements.add(it.next());
-                }
-            }
-        }
-
-        return availableChildElements;
-    }
-
-    @Override
-    protected void addAttributeValueProposals(
-            final ContentAssistRequest contentAssistRequest)
-    {
-        final ITextRegion textRegion = findNameRegionIfIsHTMLRoot(contentAssistRequest);
-
-        if (textRegion != null)
-        {
-            final IDOMNode node = (IDOMNode) contentAssistRequest.getNode();
-            final NamedNodeMap attributes = node.getAttributes();
-            final String attrName = node.getFirstStructuredDocumentRegion()
-            .getText(textRegion);
-            if (attrName != null)
-            {
-                final int colonPos = attrName.indexOf(':');
-                // must have a colon && it must not be the last char, otherwise
-                // there is no localName
-                if (colonPos > -1 && colonPos < attrName.length() - 1)
-                {
-                    final String prefix = attrName.substring(0, colonPos);
-
-                    if ("xmlns".equals(prefix))
-                    {
-                        final ITagRegistry tagRegistry = ViewUtil.getHtmlTagRegistry(_file.getProject());
-                        if (tagRegistry != null)
-                        {
-                            final Set<Attr> alreadyUsed = ViewUtil.getDeclaredNamespaces(attributes);
-                            final Collection<? extends Namespace> namespaces = tagRegistry
-                            .getAllTagLibraries();
-                            NAMESPACE_LOOP: for (final Namespace ns : namespaces)
-                            {
-                                final String possibleValue = ns.getNSUri();
-
-                                if (ViewUtil.hasAttributeValue(alreadyUsed, possibleValue))
-                                {
-                                    continue NAMESPACE_LOOP;
-                                }
-                                // we have an attribute of the form xmlns:X in
-                                // the
-                                // html root node. Here we can provide value
-                                // proposals
-                                // for all of the known namespaces.
-                                final String rString = "\"" + possibleValue + "\""; //$NON-NLS-2$//$NON-NLS-1$
-                                final int rOffset = contentAssistRequest
-                                .getReplacementBeginPosition();
-                                final int rLength = contentAssistRequest
-                                .getReplacementLength();
-                                final int cursorAfter = possibleValue.length() + 1;
-                                final String displayString = "\"" + possibleValue + "\""; //$NON-NLS-2$//$NON-NLS-1$
-
-                                final CustomCompletionProposal proposal = new CustomCompletionProposal(
-                                        rString,
-                                        rOffset,
-                                        rLength,
-                                        cursorAfter,
-                                        null,
-                                        displayString,
-                                        null,
-                                        null,
-                                        XMLRelevanceConstants.R_XML_ATTRIBUTE_VALUE);
-                                contentAssistRequest.addProposal(proposal);
-                            }
-                        }
-                        // now bail, since super only adds annoying identity completions
-                        // for this case
-                        return;
-                    }
-                }
-            }
-        }
-        super.addAttributeValueProposals(contentAssistRequest);
-    }
-
-    private ITextRegion findNameRegionIfIsHTMLRoot(
-            final ContentAssistRequest contentAssistRequest)
-    {
-        final IDOMNode node = (IDOMNode) contentAssistRequest.getNode();
-        if (node.getNodeType() == Node.ELEMENT_NODE
-                && "html".equals(node.getNodeName())
-                && node.getOwnerDocument().getDocumentElement() == node)
-        {
-            // Find the attribute region and name for which this position should
-            // have a value proposed
-            final IStructuredDocumentRegion open = node
-            .getFirstStructuredDocumentRegion();
-            final ITextRegionList openRegions = open.getRegions();
-            int i = openRegions.indexOf(contentAssistRequest.getRegion());
-            if (i < 0)
-            {
-                return null;
-            }
-            ITextRegion nameRegion = null;
-            while (i >= 0)
-            {
-                nameRegion = openRegions.get(i--);
-                if (nameRegion.getType() == DOMRegionContext.XML_TAG_ATTRIBUTE_NAME)
-                {
-                    break;
-                }
-            }
-            return nameRegion;
-        }
-        return null;
-    }
-
-    @SuppressWarnings("unchecked")
-    private Map<String, PrefixEntry> getDocumentNamespaces(
-            final FaceletDocumentFactory factory, final int offset)
-            {
-        final IStructuredDocumentContext context = IStructuredDocumentContextFactory.INSTANCE
-        .getContext(fTextViewer, offset);
-
-        Document doc = null;
-        if (context != null)
-        {
-            final IDOMContextResolver domContextResolver = IStructuredDocumentContextResolverFactory.INSTANCE
-            .getDOMContextResolver(context);
-
-            doc = domContextResolver.getDOMDocument();
-
-            if (doc == null)
-            {
-                return Collections.EMPTY_MAP;
-            }
-        }
-        return ViewUtil.getDocumentNamespaces(doc);
-            }
-
-    @Override
-    protected CMElementDeclaration getCMElementDeclaration(final Node node)
-    {
-        if (node.getNodeType() == Node.ELEMENT_NODE)
-        {
-            if (node.getPrefix() != null)
-            {
-                final Element element = (Element) node;
-
-                final CMElementDeclaration elementDecl = _factory
-                .createCMElementDeclaration(element);
-
-                if (elementDecl != null)
-                {
-                    return elementDecl;
-                }
-            }
-        }
-
-        return null;
-        // return super.getCMElementDeclaration(node);
-    }
-
-    private boolean shouldContribute(final IFile file)
-    {
-        return ViewUtil.isFaceletVDLFile(file);
-    }
-
-    private IFile getFile(final ITextViewer textViewer,
-            final int documentPosition)
-    {
-        final IStructuredDocumentContext context = IStructuredDocumentContextFactory.INSTANCE
-        .getContext(textViewer, documentPosition);
-
-        if (context != null)
-        {
-            final IWorkspaceContextResolver resolver = IStructuredDocumentContextResolverFactory.INSTANCE
-            .getWorkspaceContextResolver(context);
-
-            if (resolver != null)
-            {
-                final IResource resource = resolver.getResource();
-                if (resource != null &&
-                        resource.getType() == IResource.FILE)
-                {
-                    return (IFile) resource;
-                }
-            }
-        }
-        return null;
-    }
-}
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/contentassist/XHTMLContentAssistProcessor2.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/contentassist/XHTMLContentAssistProcessor2.java
deleted file mode 100644
index 47ac591..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/contentassist/XHTMLContentAssistProcessor2.java
+++ /dev/null
@@ -1,335 +0,0 @@
-package org.eclipse.jst.jsf.facelet.ui.internal.contentassist;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.jface.text.ITextViewer;
-import org.eclipse.jface.text.contentassist.CompletionProposal;
-import org.eclipse.jface.text.contentassist.ICompletionProposal;
-import org.eclipse.jface.text.contentassist.IContentAssistProcessor;
-import org.eclipse.jface.text.contentassist.IContextInformation;
-import org.eclipse.jface.text.contentassist.IContextInformationValidator;
-import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.ITagElement;
-import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.Namespace;
-import org.eclipse.jst.jsf.context.resolver.structureddocument.IDOMContextResolver;
-import org.eclipse.jst.jsf.context.resolver.structureddocument.IStructuredDocumentContextResolverFactory;
-import org.eclipse.jst.jsf.context.resolver.structureddocument.IWorkspaceContextResolver;
-import org.eclipse.jst.jsf.context.resolver.structureddocument.internal.ITextRegionContextResolver;
-import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContext;
-import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContextFactory;
-import org.eclipse.jst.jsf.designtime.internal.view.model.ITagRegistry;
-import org.eclipse.jst.jsf.designtime.internal.view.model.TagRegistryFactory.TagRegistryFactoryException;
-import org.eclipse.jst.jsf.facelet.core.internal.registry.FaceletRegistryManager.MyRegistryFactory;
-import org.eclipse.jst.jsf.facelet.ui.internal.FaceletUiPlugin;
-import org.eclipse.wst.xml.core.internal.regions.DOMRegionContext;
-import org.w3c.dom.Attr;
-import org.w3c.dom.Document;
-import org.w3c.dom.Element;
-import org.w3c.dom.NamedNodeMap;
-
-/**
- * Temporary.
- * 
- * @author cbateman
- *
- */
-public class XHTMLContentAssistProcessor2 implements IContentAssistProcessor
-{
-    private final static ICompletionProposal[] NO_PROPOSALS = new ICompletionProposal[0];
-
-    public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer,
-            int offset)
-    {
-        List<ICompletionProposal> proposals = new ArrayList<ICompletionProposal>();
-        final IStructuredDocumentContext context = IStructuredDocumentContextFactory.INSTANCE
-                .getContext(viewer, offset);
-
-        if (context != null)
-        {
-            final IDOMContextResolver domContextResolver = IStructuredDocumentContextResolverFactory.INSTANCE
-                    .getDOMContextResolver(context);
-
-            final Document doc = domContextResolver.getDOMDocument();
-
-            if (doc == null)
-            {
-                return NO_PROPOSALS;
-            }
-
-            // get the namespaces that are already declared
-            final Map<String, PrefixEntry> documentNamespaces = getDocumentNamespaces(doc);
-
-            final ITextRegionContextResolver resolver = IStructuredDocumentContextResolverFactory.INSTANCE
-                    .getTextRegionResolver(context);
-
-            if (resolver != null)
-            {
-                final String regionType = resolver.getRegionType();
-
-                if (DOMRegionContext.XML_CONTENT.equals(regionType))
-                {
-                    // TODO: this may be in the open it may occur on the inside
-                    // of a
-                    // "<" that doesn't have any further tag name yet
-                    proposals = getTagCompletionsForDocument(context,
-                            documentNamespaces, TagPrefix.NO_PREFIX);
-                }
-                else if (DOMRegionContext.XML_TAG_NAME.equals(regionType))
-                {
-                    final TagPrefix tagPrefix = new TagPrefix(resolver
-                            .getRegionText());
-                    proposals = getTagCompletionsForDocument(context,
-                            documentNamespaces, tagPrefix);
-                }
-                else
-                {
-                    System.out.println(regionType);
-                }
-            }
-        }
-
-        return proposals.toArray(NO_PROPOSALS);
-    }
-
-    private List<ICompletionProposal> getTagCompletionsForDocument(
-            final IStructuredDocumentContext context,
-            final Map<String, PrefixEntry> namespaces, final TagPrefix tagPrefix)
-    {
-        final List<ICompletionProposal> proposals = new ArrayList<ICompletionProposal>();
-
-        final IWorkspaceContextResolver wkspaceResolver = IStructuredDocumentContextResolverFactory.INSTANCE
-                .getWorkspaceContextResolver(context);
-        final IProject project = wkspaceResolver.getProject();
-
-        MyRegistryFactory factory = new MyRegistryFactory();
-        ITagRegistry registry;
-        try
-        {
-            registry = factory.createTagRegistry(project);
-            if (registry == null)
-            {
-                return proposals;
-            }
-
-            final Collection<? extends Namespace> tagLibs = registry
-                    .getAllTagLibraries();
-
-            for (final Namespace tagLib : tagLibs)
-            {
-                final PrefixEntry ns = namespaces.get(tagLib.getNSUri());
-
-                // if the tag library is not initialized, don't trigger
-                // a potentially expensive operation during the content assist
-                if (ns != null && tagLib.isInitialized())
-                {
-                    // only add if this namespace's prefix starts with
-                    // the prefix that the user provided
-                    if (ns._prefix.startsWith(tagPrefix.getPrefix()))
-                    {
-                        final Collection<?> tags = tagLib.getViewElements();
-
-                        for (final Iterator<?> it = tags.iterator(); it
-                                .hasNext();)
-                        {
-                            final ITagElement tagElement = (ITagElement) it
-                                    .next();
-
-                            // only add an element it starts with the prefix
-                            // provided
-                            if (tagElement.getName().startsWith(
-                                    tagPrefix.getLocalName()))
-                            {
-                                final String userPrefix = tagPrefix
-                                        .getUserPrefix();
-
-                                final String tagName = ns._prefix + ":"
-                                        + tagElement.getName();
-                                String replacementText = "";
-                                if ("".equals(userPrefix))
-                                {
-                                    replacementText = "<" + tagName + "></"
-                                            + tagName + ">";
-                                }
-                                else
-                                {
-                                    replacementText = tagName
-                                            .substring(userPrefix.length());
-                                }
-                                proposals.add(new CompletionProposal(
-                                        replacementText, context
-                                                .getDocumentPosition(), 0, 0,
-                                        null, tagName, null, null));
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        catch (TagRegistryFactoryException e)
-        {
-            FaceletUiPlugin.log(e);
-        }
-
-        return proposals;
-    }
-
-    private Map<String, PrefixEntry> getDocumentNamespaces(Document doc)
-    {
-        final Map<String, PrefixEntry> namespaces = new HashMap<String, PrefixEntry>();
-
-        Element rootElement = doc.getDocumentElement();
-
-        if (rootElement != null)
-        {
-            NamedNodeMap attrs = rootElement.getAttributes();
-            for (int i = 0; i < attrs.getLength(); i++)
-            {
-                Attr a = (Attr) attrs.item(i);
-                PrefixEntry ns = PrefixEntry.parseNamespace(a);
-                if (ns != null)
-                {
-                    namespaces.put(ns.getUri(), ns);
-                }
-            }
-        }
-
-        return namespaces;
-    }
-
-    private static class TagPrefix
-    {
-        public final static TagPrefix NO_PREFIX = new TagPrefix("");
-
-        private final String          _prefix;
-        private final String          _localName;
-        private final boolean         _hasColon;
-
-        public TagPrefix(final String tagName)
-        {
-            int prefixIdx = tagName.indexOf(':');
-
-            if (prefixIdx != -1)
-            {
-                _prefix = tagName.substring(0, prefixIdx);
-                _hasColon = true;
-                if (tagName.length() > prefixIdx)
-                {
-                    _localName = tagName.substring(prefixIdx + 1);
-                }
-                else
-                {
-                    _localName = "";
-                }
-            }
-            else
-            {
-                _hasColon = false;
-                _prefix = tagName;
-                _localName = "";
-            }
-        }
-
-        public String getUserPrefix()
-        {
-            String userPrefix = _prefix;
-
-            if (_hasColon)
-            {
-                userPrefix += ":";
-                userPrefix += _localName;
-            }
-
-            return userPrefix;
-        }
-
-        public String getPrefix()
-        {
-            return _prefix;
-        }
-
-        public String getLocalName()
-        {
-            return _localName;
-        }
-    }
-
-    private static class PrefixEntry
-    {
-        private final String _uri;
-        private final String _prefix;
-
-        public static PrefixEntry parseNamespace(Attr attr)
-        {
-            final String prefix = attr.getPrefix();
-
-            if ("xmlns".equals(prefix))
-            {
-                final String prefixName = attr.getLocalName();
-                if (prefixName != null)
-                {
-                    final String uri = attr.getNodeValue();
-
-                    if (uri != null)
-                    {
-                        return new PrefixEntry(uri, prefixName);
-                    }
-                }
-            }
-
-            return null;
-        }
-
-        public PrefixEntry(final String uri, final String prefix)
-        {
-            _uri = uri;
-            _prefix = prefix;
-        }
-
-        public final String getUri()
-        {
-            return _uri;
-        }
-
-        public int hashCode()
-        {
-            return _uri.hashCode();
-        }
-
-        public boolean equals(Object obj)
-        {
-            return _uri.equals(obj);
-        }
-    }
-
-    public IContextInformation[] computeContextInformation(ITextViewer viewer,
-            int offset)
-    {
-        return null;
-    }
-
-    public char[] getCompletionProposalAutoActivationCharacters()
-    {
-        return null;
-    }
-
-    public char[] getContextInformationAutoActivationCharacters()
-    {
-        return null;
-    }
-
-    public IContextInformationValidator getContextInformationValidator()
-    {
-        return null;
-    }
-
-    public String getErrorMessage()
-    {
-        return null;
-    }
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/facet/FaceletChangePage.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/facet/FaceletChangePage.java
deleted file mode 100644
index 24996aa..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/facet/FaceletChangePage.java
+++ /dev/null
@@ -1,163 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Cameron Bateman - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.facelet.ui.internal.facet;
-
-import org.eclipse.core.databinding.DataBindingContext;
-import org.eclipse.core.databinding.beans.BeansObservables;
-import org.eclipse.core.databinding.observable.value.IObservableValue;
-import org.eclipse.jface.databinding.swt.SWTObservables;
-import org.eclipse.jst.jsf.facelet.core.internal.facet.ChangeActionType;
-import org.eclipse.jst.jsf.facelet.core.internal.facet.FacetChangeModel;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.layout.RowData;
-import org.eclipse.swt.layout.RowLayout;
-import org.eclipse.swt.widgets.Button;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Group;
-import org.eclipse.wst.common.project.facet.ui.AbstractFacetWizardPage;
-
-/**
- * A common facet change UI page, mainly used for facet install/uninstall.
- * 
- * @author cbateman
- *
- */
-public abstract class FaceletChangePage extends AbstractFacetWizardPage
-{
-    private Button             _chgDefaultSuffix;
-    private Button             _chgViewHandler;
-    private Button             _chgConfigureListener;
-    private Button             _chgWebappLifecycleListener;
-
-    private DataBindingContext _bindingContext;
-    private FacetChangeModel _dataModel;
-
-    /**
-     * @param name
-     */
-    public FaceletChangePage(String name)
-    {
-        super(name);
-    }
-
-    public void setConfig(final Object config)
-    {
-        _dataModel = (FacetChangeModel) config;
-    }
-
-    /**
-     * @return the name of the change based on the actionType enumeration.
-     */
-    protected String getTextForChangeType()
-    {
-        final ChangeActionType actionType = _dataModel.getChangeActionType();
-
-        switch (actionType)
-        {
-            case ADD:
-                return "Add";
-
-            case REMOVE:
-                return "Remove";
-        }
-
-        return "*ERROR*";
-    }
-
-    private void initDefaultSuffixButton(final Composite parent)
-    {
-        _chgDefaultSuffix = new Button(parent, SWT.CHECK);
-        _chgDefaultSuffix.setText(getTextForChangeType() + " '.xhtml' DEFAULT_SUFFIX parameter");
-        _chgDefaultSuffix.setSelection(_dataModel.isChgDefaultSuffix());
-        _chgDefaultSuffix.setLayoutData(new RowData());
-        IObservableValue modelObservable = BeansObservables.observeValue(
-                _dataModel, "chgDefaultSuffix");
-
-        _bindingContext.bindValue(SWTObservables
-                .observeSelection(_chgDefaultSuffix), modelObservable, null,
-                null);
-    }
-
-    private void initViewHandlerButton(final Composite parent)
-    {
-        _chgViewHandler = new Button(parent, SWT.CHECK);
-        _chgViewHandler.setText(getTextForChangeType() + " Facelet view handler");
-        _chgViewHandler.setSelection(_dataModel.isChgViewHandler());
-        _chgViewHandler.setLayoutData(new RowData());
-        IObservableValue modelObservable = BeansObservables.observeValue(
-                _dataModel, "chgViewHandler");
-
-        _bindingContext
-                .bindValue(SWTObservables.observeSelection(_chgViewHandler),
-                        modelObservable, null, null);
-    }
-
-    private void initConfigureListener(final Composite parent)
-    {
-        _chgConfigureListener = new Button(parent, SWT.CHECK);
-        _chgConfigureListener
-                .setText(getTextForChangeType() + " configure listener (needed by some Tomcat containers)");
-        _chgConfigureListener.setSelection(_dataModel.isChgConfigureListener());
-        _chgConfigureListener.setLayoutData(new RowData());
-        IObservableValue modelObservable = BeansObservables.observeValue(
-                _dataModel, "chgConfigureListener");
-
-        _bindingContext.bindValue(SWTObservables
-                .observeSelection(_chgConfigureListener), modelObservable,
-                null, null);
-    }
-
-    private void initWebappLifecycleListener(final Composite parent)
-    {
-        _chgWebappLifecycleListener = new Button(parent, SWT.CHECK);
-        _chgWebappLifecycleListener
-                .setText(getTextForChangeType() + " web application lifecycle listener (needed by some Tomcat containers)");
-        _chgWebappLifecycleListener.setSelection(_dataModel
-                .isChgConfigureListener());
-        _chgWebappLifecycleListener.setLayoutData(new RowData());
-        IObservableValue modelObservable = BeansObservables.observeValue(
-                _dataModel, "chgWebAppLifecycleListener");
-
-        _bindingContext.bindValue(SWTObservables
-                .observeSelection(_chgWebappLifecycleListener),
-                modelObservable, null, null);
-    }
-
-    public void createControl(final Composite parent)
-    {
-        setTitle("Facelet");
-        setMessage("Configure Facelet settings");
-
-        _bindingContext = new DataBindingContext();
-
-        // WizardPageSupport.create(this, _bindingContext);
-
-        final Composite control = new Composite(parent, SWT.NONE);
-        final RowLayout rowLayout = new RowLayout(SWT.VERTICAL);
-        rowLayout.fill = true;
-        control.setLayout(rowLayout);
-
-        final Group webXMLGroup = new Group(control, SWT.NONE);
-        webXMLGroup.setLayout(rowLayout);
-        webXMLGroup.setText("Deployment Descriptor (web.xml) Configuration");
-        initDefaultSuffixButton(webXMLGroup);
-        initConfigureListener(webXMLGroup);
-        initWebappLifecycleListener(webXMLGroup);
-
-        final Group facesConfigGroup = new Group(control, SWT.NONE);
-        facesConfigGroup.setLayout(rowLayout);
-        facesConfigGroup
-                .setText("Application (faces-config.xml) Configuration");
-        initViewHandlerButton(facesConfigGroup);
-
-        setControl(control);
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/facet/FaceletInstallPage.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/facet/FaceletInstallPage.java
deleted file mode 100644
index 2ef2c5c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/facet/FaceletInstallPage.java
+++ /dev/null
@@ -1,18 +0,0 @@
-package org.eclipse.jst.jsf.facelet.ui.internal.facet;
-
-
-/**
- * The UI page for installing the Facelet facet.
- * @author cbateman
- *
- */
-public class FaceletInstallPage extends FaceletChangePage
-{
-    /**
-     * 
-     */
-    public FaceletInstallPage()
-    {
-        super("Facelet Install Page");
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/facet/FaceletUninstallPage.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/facet/FaceletUninstallPage.java
deleted file mode 100644
index f0e0c2f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/facet/FaceletUninstallPage.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Cameron Bateman - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facelet.ui.internal.facet;
-
-/**
- * The uninstall page for the Facelet facet.
- * 
- * @author cbateman
- *
- */
-public class FaceletUninstallPage extends FaceletChangePage
-{
-    /**
-     * 
-     */
-    public FaceletUninstallPage()
-    {
-        super("Facelet Uninstall Page");
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/hover/FaceletHover.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/hover/FaceletHover.java
deleted file mode 100644
index 9fe5821..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/hover/FaceletHover.java
+++ /dev/null
@@ -1,143 +0,0 @@
-package org.eclipse.jst.jsf.facelet.ui.internal.hover;
-
-import org.eclipse.core.resources.IProject;
-import org.eclipse.jface.text.IRegion;
-import org.eclipse.jface.text.ITextHover;
-import org.eclipse.jface.text.ITextViewer;
-import org.eclipse.jst.jsf.context.resolver.structureddocument.IStructuredDocumentContextResolverFactory;
-import org.eclipse.jst.jsf.context.resolver.structureddocument.IWorkspaceContextResolver;
-import org.eclipse.jst.jsf.context.resolver.structureddocument.internal.ITextRegionContextResolver;
-import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContext;
-import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContextFactory;
-import org.eclipse.jst.jsf.facelet.core.internal.cm.FaceletDocumentFactory;
-import org.eclipse.jst.jsf.ui.internal.jspeditor.JSFELHover;
-import org.eclipse.wst.html.ui.internal.taginfo.HTMLTagInfoHoverProcessor;
-import org.eclipse.wst.xml.core.internal.contentmodel.CMElementDeclaration;
-import org.eclipse.wst.xml.core.internal.regions.DOMRegionContext;
-import org.w3c.dom.Element;
-import org.w3c.dom.Node;
-
-/**
- * The text hover for Facelets in html documents.
- * 
- * @author cbateman
- *
- */
-public class FaceletHover implements ITextHover
-{
-    private IProject                  _project;
-    private JSFELHover                _elHover;
-    private HTMLTagInfoHoverProcessor _htmlHoverProcessor;
-
-    /**
-     * 
-     */
-    public FaceletHover()
-    {
-        _elHover = new JSFELHover();
-        _htmlHoverProcessor = new MyHTMLTagInfoHoverProcessor();
-    }
-
-    public String getHoverInfo(ITextViewer textViewer, IRegion hoverRegion)
-    {
-        final IStructuredDocumentContext context = IStructuredDocumentContextFactory.INSTANCE
-                .getContext(textViewer, hoverRegion.getOffset());
-        String info = null;
-        if (isInAttributeValue(context))
-        {
-            info = _elHover.getHoverInfo(textViewer, hoverRegion);
-        }
-
-        if (info == null)
-        {
-            if (context != null)
-            {
-                _project = getProject(context);
-            }
-
-            info = _htmlHoverProcessor.getHoverInfo(textViewer, hoverRegion);
-        }
-
-        return info;
-    }
-
-    public IRegion getHoverRegion(ITextViewer textViewer, int offset)
-    {
-        IRegion region = null;
-        final IStructuredDocumentContext context = IStructuredDocumentContextFactory.INSTANCE
-                .getContext(textViewer, offset);
-
-        // if we are in an attribute value, try to get a region from the
-        // el hover first
-        if (context != null)
-        {
-            if (isInAttributeValue(context))
-            {
-                region = _elHover.getHoverRegion(textViewer, offset);
-            }
-        }
-
-        if (region == null)
-        {
-            if (context != null)
-            {
-                _project = getProject(context);
-            }
-            region = _htmlHoverProcessor.getHoverRegion(textViewer, offset);
-        }
-
-        return region;
-    }
-
-    private boolean isInAttributeValue(final IStructuredDocumentContext context)
-    {
-        final ITextRegionContextResolver resolver = IStructuredDocumentContextResolverFactory.INSTANCE
-                .getTextRegionResolver(context);
-        final String regionType = resolver.getRegionType();
-        if (regionType != null
-                && (regionType == DOMRegionContext.XML_TAG_ATTRIBUTE_VALUE || resolver
-                        .matchesRelative(new String[]
-                        { DOMRegionContext.XML_TAG_ATTRIBUTE_VALUE })))
-        {
-            return true;
-        }
-
-        return false;
-    }
-
-    private IProject getProject(final IStructuredDocumentContext context)
-    {
-        final IWorkspaceContextResolver resolver = IStructuredDocumentContextResolverFactory.INSTANCE
-                .getWorkspaceContextResolver(context);
-
-        if (resolver != null)
-        {
-            return resolver.getProject();
-        }
-        return null;
-    }
-
-    private class MyHTMLTagInfoHoverProcessor extends HTMLTagInfoHoverProcessor
-    {
-        @Override
-        protected CMElementDeclaration getCMElementDeclaration(Node node)
-        {
-            if (_project != null && node.getNodeType() == Node.ELEMENT_NODE
-                    && node.getPrefix() != null)
-            {
-                final Element element = (Element) node;
-                final FaceletDocumentFactory factory = new FaceletDocumentFactory(_project);
-
-                final CMElementDeclaration elementDecl = factory
-                        .createCMElementDeclaration(element);
-
-                if (elementDecl != null)
-                {
-                    return elementDecl;
-                }
-            }
-
-            return super.getCMElementDeclaration(node);
-        }
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/htmleditor/FaceletELHyperlinkDetector.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/htmleditor/FaceletELHyperlinkDetector.java
deleted file mode 100644
index 703eeee..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/htmleditor/FaceletELHyperlinkDetector.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2010 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.facelet.ui.internal.htmleditor;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.jst.jsf.context.resolver.structureddocument.IStructuredDocumentContextResolverFactory;
-import org.eclipse.jst.jsf.context.resolver.structureddocument.IWorkspaceContextResolver;
-import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContext;
-import org.eclipse.jst.jsf.ui.internal.jspeditor.AbstractELHyperlinkDetector;
-
-/**
- * This HyperlinkDetector creates hyperlinks for symbols in JSF EL expressions
- * inside facelet files.
- */
-public class FaceletELHyperlinkDetector extends AbstractELHyperlinkDetector {
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.eclipse.jst.jsf.ui.internal.jspeditor.AbstractELHyperlinkDetector#isEnabled(org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContext)
-	 */
-	@Override
-	protected boolean isEnabled(IStructuredDocumentContext context) {
-		boolean enabled = false;
-		if (context != null) {
-			IWorkspaceContextResolver resolver =
-				IStructuredDocumentContextResolverFactory.INSTANCE.getWorkspaceContextResolver(context);
-			if (resolver != null) {
-				IResource resource = resolver.getResource();
-				if (resource instanceof IFile) {
-					IFile file = (IFile)resource;
-					String filename = file.getFullPath().toString();
-					enabled =
-						hasContentType(filename, "jsf.facelet") || //$NON-NLS-1$
-						hasContentType(filename, "jsf.facelet.composite"); //$NON-NLS-1$
-				}
-			}
-		}
-		return enabled;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/validation/HTMLValidator.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/validation/HTMLValidator.java
deleted file mode 100644
index b3df148..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/validation/HTMLValidator.java
+++ /dev/null
@@ -1,280 +0,0 @@
-package org.eclipse.jst.jsf.facelet.ui.internal.validation;
-
-import java.io.IOException;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Set;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.resources.IWorkspaceRoot;
-import org.eclipse.core.resources.ResourcesPlugin;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.core.runtime.Platform;
-import org.eclipse.core.runtime.Status;
-import org.eclipse.core.runtime.content.IContentType;
-import org.eclipse.core.runtime.content.IContentTypeManager;
-import org.eclipse.core.runtime.jobs.ISchedulingRule;
-import org.eclipse.emf.common.util.Diagnostic;
-import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.Namespace;
-import org.eclipse.jst.jsf.context.resolver.structureddocument.IDOMContextResolver;
-import org.eclipse.jst.jsf.context.resolver.structureddocument.IStructuredDocumentContextResolverFactory;
-import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContext;
-import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContextFactory;
-import org.eclipse.jst.jsf.core.internal.JSFCorePlugin;
-import org.eclipse.jst.jsf.designtime.internal.view.model.ITagRegistry;
-import org.eclipse.jst.jsf.facelet.core.internal.util.ViewUtil;
-import org.eclipse.jst.jsf.facelet.ui.internal.FaceletUiPlugin;
-import org.eclipse.jst.jsf.validation.internal.IJSFViewValidator;
-import org.eclipse.jst.jsf.validation.internal.JSFValidatorFactory;
-import org.eclipse.jst.jsf.validation.internal.ValidationPreferences;
-import org.eclipse.jst.jsf.validation.internal.facelet.FaceletDiagnosticFactory;
-import org.eclipse.wst.sse.core.StructuredModelManager;
-import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
-import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
-import org.eclipse.wst.validation.AbstractValidator;
-import org.eclipse.wst.validation.ValidationResult;
-import org.eclipse.wst.validation.ValidationState;
-import org.eclipse.wst.validation.internal.core.ValidationException;
-import org.eclipse.wst.validation.internal.operations.LocalizedMessage;
-import org.eclipse.wst.validation.internal.provisional.core.IMessage;
-import org.eclipse.wst.validation.internal.provisional.core.IReporter;
-import org.eclipse.wst.validation.internal.provisional.core.IValidationContext;
-import org.eclipse.wst.validation.internal.provisional.core.IValidator;
-import org.eclipse.wst.xml.core.internal.provisional.document.IDOMAttr;
-import org.w3c.dom.Attr;
-import org.w3c.dom.Document;
-import org.w3c.dom.Element;
-
-/**
- * The Facelet HTML file validator.
- * 
- * @author cbateman
- *
- */
-public class HTMLValidator extends AbstractValidator implements IValidator
-{
-	private FaceletDiagnosticFactory _diagnosticFactory = new FaceletDiagnosticFactory();
-    /**
-     * @param helper
-     * @return no rule, null
-     */
-    public ISchedulingRule getSchedulingRule(final IValidationContext helper)
-    {
-        // no rule...
-        return null;
-    }
-
-    /**
-     * @param helper
-     * @param reporter
-     * @return status of this validation
-     * @throws ValidationException
-     */
-    public IStatus validateInJob(final IValidationContext helper,
-            final IReporter reporter) throws ValidationException
-    {
-        IStatus status = Status.OK_STATUS;
-        try
-        {
-            validate(helper, reporter);
-        }
-        catch (final ValidationException e)
-        {
-            status = new Status(IStatus.ERROR, FaceletUiPlugin.PLUGIN_ID,
-                    IStatus.ERROR, e.getLocalizedMessage(), e);
-        }
-        return status;
-
-    }
-
-    public void cleanup(final IReporter reporter)
-    {
-        // do nothing
-    }
-
-    @Override
-	public ValidationResult validate(IResource resource, int kind, ValidationState state, IProgressMonitor monitor){
-		ValidationResult vr = new ValidationResult();
-		if (resource == null || !(resource instanceof IFile)) {
-			return vr;
-		}
-		IFile currentFile = (IFile) resource;
-        if (shouldValidate(currentFile)) {
-            validateFile(currentFile, vr.getReporter(monitor));
-        }
-		return vr;
-	}
-
-    public void validate(final IValidationContext helper,
-            final IReporter reporter) throws ValidationException
-    {
-        final String[] uris = helper.getURIs();
-        final IWorkspaceRoot wsRoot = ResourcesPlugin.getWorkspace().getRoot();
-        if (uris.length > 0)
-        {
-            IFile currentFile = null;
-
-            for (int i = 0; i < uris.length && !reporter.isCancelled(); i++)
-            {
-                currentFile = wsRoot.getFile(new Path(uris[i]));
-                if (currentFile != null && currentFile.exists())
-                {
-                    if (shouldValidate(currentFile))
-                    {
-                        final int percent = (i * 100) / uris.length + 1;
-                        final IMessage message = new LocalizedMessage(
-                                IMessage.LOW_SEVERITY, percent + "% " + uris[i]);
-                        reporter.displaySubtask(this, message);
-
-                        validateFile(currentFile, reporter);
-                    }
-                }
-            }
-        }
-
-    }
-
-    private void validateFile(final IFile file, final IReporter reporter)
-    {
-        final IJSFViewValidator validator = JSFValidatorFactory
-                .createDefaultXMLValidator();
-        final ValidationPreferences prefs = new ValidationPreferences(
-                JSFCorePlugin.getDefault().getPreferenceStore());
-        prefs.load();
-
-        IStructuredModel model = null;
-        try
-        {
-            model = StructuredModelManager.getModelManager().getModelForRead(
-                    file);
-
-            final ValidationReporter jsfReporter = new ValidationReporter(this,
-                    reporter, file, prefs, model);
-            validator.validateView(file, jsfReporter);
-            // TODO: break off into composite strategies
-            validateFaceletHtml(file, jsfReporter);
-        }
-        catch (final CoreException e)
-        {
-            JSFCorePlugin.log("Error validating JSF", e);
-        }
-        catch (final IOException e)
-        {
-            JSFCorePlugin.log("Error validating JSF", e);
-        }
-        finally
-        {
-            if (null != model)
-            {
-                model.releaseFromRead();
-            }
-        }
-    }
-
-    private void validateFaceletHtml(final IFile file,
-            final ValidationReporter reporter)
-    {
-        IStructuredModel model = null;
-        try
-        {
-            model = StructuredModelManager.getModelManager().getModelForRead(
-                    file);
-
-            final IStructuredDocument structuredDoc = model
-                    .getStructuredDocument();
-
-            validateDocument(structuredDoc, reporter, file.getProject());
-        }
-        catch (final CoreException e)
-        {
-            JSFCorePlugin.log("Error validating JSF", e);
-        }
-        catch (final IOException e)
-        {
-            JSFCorePlugin.log("Error validating JSF", e);
-        }
-        finally
-        {
-            if (null != model)
-            {
-                model.releaseFromRead();
-            }
-        }
-    }
-
-    private void validateDocument(IStructuredDocument structuredDoc,
-            final ValidationReporter reporter, IProject project)
-    {
-        validateRoot(structuredDoc, reporter, project);
-    }
-
-    private void validateRoot(IStructuredDocument structuredDoc,
-            ValidationReporter reporter, IProject project)
-    {
-        final IStructuredDocumentContext context = IStructuredDocumentContextFactory.INSTANCE
-                .getContext(structuredDoc, -1);
-        final IDOMContextResolver resolver = IStructuredDocumentContextResolverFactory.INSTANCE
-                .getDOMContextResolver(context);
-        final Document document = resolver.getDOMDocument();
-        Element rootElement = document.getDocumentElement();
-
-        if ("html".equals(rootElement.getNodeName()))
-        {
-            final Set<Attr> declaredNamespaces = ViewUtil
-                    .getDeclaredNamespaces(rootElement.getAttributes());
-            final ITagRegistry tagRegistry = ViewUtil
-                    .getHtmlTagRegistry(project);
-            final Collection<? extends Namespace> namespaces;
-            if (tagRegistry != null)
-            {
-                namespaces = tagRegistry.getAllTagLibraries();
-            }
-            else
-            {
-                // unexpected
-                namespaces = Collections.EMPTY_SET;
-                JSFCorePlugin.log(IStatus.ERROR, "Program Error: HTML tag registry not found"); //$NON-NLS-1$
-            }
-
-            for (final Attr attr : declaredNamespaces)
-            {
-                // only validate prefix declarations
-                if (attr.getPrefix() != null && attr instanceof IDOMAttr)
-                {
-                    final String declaredUri = attr.getValue();
-                    String findUri = null;
-                    SEARCH_NAMESPACES: for (final Namespace ns : namespaces)
-                    {
-                        if (ns.getNSUri().equals(declaredUri))
-                        {
-                            findUri = ns.getNSUri();
-                            break SEARCH_NAMESPACES;
-                        }
-                    }
-
-                    if (findUri == null)
-                    {
-                        final Diagnostic diag = _diagnosticFactory.create_CANNOT_FIND_FACELET_TAGLIB(declaredUri);
-                        final IDOMAttr domAttr = (IDOMAttr) attr;
-                        reporter.report(diag, domAttr.getValueRegionStartOffset(), domAttr
-                                .getValue().length());
-                    }
-                }
-            }
-        }
-    }
-    
-    private boolean shouldValidate(final IFile model)
-    {
-        final IContentTypeManager manager = Platform.getContentTypeManager();
-        final IContentType contentType = manager
-                .getContentType("org.eclipse.wst.html.core.htmlsource");
-        return (contentType.isAssociatedWith(model.getName()))
-                && ViewUtil.isFaceletVDLFile(model);
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/validation/ValidationReporter.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/validation/ValidationReporter.java
deleted file mode 100644
index 2e87e82..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/src/org/eclipse/jst/jsf/facelet/ui/internal/validation/ValidationReporter.java
+++ /dev/null
@@ -1,69 +0,0 @@
-package org.eclipse.jst.jsf.facelet.ui.internal.validation;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.emf.common.util.Diagnostic;
-import org.eclipse.jst.jsf.ui.internal.validation.ValidationMessageFactory;
-import org.eclipse.jst.jsf.validation.internal.IJSFViewValidator;
-import org.eclipse.jst.jsf.validation.internal.ValidationPreferences;
-import org.eclipse.jst.jsf.validation.internal.strategy.DiagnosticFactory;
-import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
-import org.eclipse.wst.validation.internal.provisional.core.IMessage;
-import org.eclipse.wst.validation.internal.provisional.core.IReporter;
-import org.eclipse.wst.validation.internal.provisional.core.IValidator;
-
-/*package*/class ValidationReporter implements
-        IJSFViewValidator.IValidationReporter
-{
-    private final IValidator _validator;
-    private final IReporter _reporter;
-    private final IFile _file;
-    private final ValidationMessageFactory _factory;
-
-    public ValidationReporter(final IValidator validator,
-            final IReporter reporter, final IFile file,
-            final ValidationPreferences prefs, final IStructuredModel model)
-    {
-        _validator = validator;
-        _reporter = reporter;
-        _file = file;
-        _factory = new ValidationMessageFactory(prefs, model);
-    }
-
-    public void report(final Diagnostic problem, final int start,
-            final int length)
-    {
-        if (shouldReportProblem(problem.getCode()))
-        {
-            final IMessage message = _factory.createFromDiagnostic(problem,
-                    start, length, _file);
-            if ((message.getSeverity() & IMessage.ALL_MESSAGES) != 0)
-            {
-                _reporter.addMessage(_validator, message);
-            }
-        }
-    }
-
-    /**
-     * @param problemCode
-     * @return filters out problems to be reported by code
-     */
-    private boolean shouldReportProblem(final int problemCode)
-    {
-        switch (problemCode)
-        {
-            case DiagnosticFactory.CONTAINMENT_ERROR_MISSING_VIEW:
-                return false;
-            default:
-                return true;
-        }
-    }
-
-    public void report(IMessage message)
-    {
-        // not capable of filtering problems by code... should not be used
-        if ((message.getSeverity() & IMessage.ALL_MESSAGES) != 0)
-        {
-            _reporter.addMessage(_validator, message);
-        }
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/templates/templates.properties b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/templates/templates.properties
deleted file mode 100644
index 1b2b72b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/templates/templates.properties
+++ /dev/null
@@ -1,15 +0,0 @@
-New_Facelet_Footer=New Facelet Footer
-New_Footer_Description=Creates a footer for use with the Facelet template.
-
-New_Facelet_Header=New Facelet Header
-New_Facelet_Header_Description=Creates a header for use with the Facelet template
-
-New_Facelet_Template=New Facelet Template
-New_Facelet_Template_Description=Creates a basic header/content/footer Facelet template
-
-New_Simple_Facelet_Composition_Page=New Facelet Composition Page
-New_Simple_Facelet_Composition_Page_Description=Creates a new Facelet page for use with a template.
-New_Facelet_Header.header=<?xml version="1.0" encoding="ISO-8859-1" ?>\n<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">\n<html xmlns="http://www.w3.org/1999/xhtml">\n<body>\n<div style="width:100%;font-size:36px;line-height:48px;background-color:navy;color:white">My Facelet Application</div>\n</body>\n</html>\n
-New_Facelet_Footer.footer=<?xml version="1.0" encoding="ISO-8859-1" ?>\n<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">\n<html xmlns="http://www.w3.org/1999/xhtml">\n<head>\n<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />\n<title>Insert title here</title>\n</head>\n<body>\n<div style="background-color:navy;width:100%;color:white"></div>\n</body>\n</html>\n
-New_Facelet_Template.template=<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" \n          "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">\n<html xmlns="http://www.w3.org/1999/xhtml"\n      xmlns:ui="http://java.sun.com/jsf/facelets">\n<head>\n  <title><ui:insert name="title">Default title</ui:insert></title>\n</head>\n\n<body>\n\n<div id="header">\n    <ui:insert name="header">\n    	Header area.  See comments below this line in the source.\n    	<!--  include your header file or uncomment the include below and create header.xhtml in this directory -->\n    	<!-- <ui:include src="header.xhtml"/> -->\n    </ui:insert>\n</div>\n\n\n<div id="content">\n  <ui:insert name="content">\n    	Content area.  See comments below this line in the source.\n    	<!--  include your content file or uncomment the include below and create content.xhtml in this directory -->\n	  	<!-- <div> -->\n    	<!-- <ui:include src="content.xhtml"/> -->  \n    	<!-- </div> -->\n  </ui:insert>\n</div>\n\n<div id="footer">\n  <ui:insert name="footer">\n    	Footer area.  See comments below this line in the source.\n    	<!--  include your header file or uncomment the include below and create footer.xhtml in this directory -->\n		<!--<ui:include src="footer.xhtml"/>  -->\n  </ui:insert>\n</div>\n\n</body>\n\n</html>\n
-New_Simple_Facelet_Composition_Page.composition=<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" \n    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">\n\n<html xmlns="http://www.w3.org/1999/xhtml"\n	xmlns:ui="http://java.sun.com/jsf/facelets"\n	xmlns:h="http://java.sun.com/jsf/html"\n	xmlns:f="http://java.sun.com/jsf/core">\n\n<ui:composition template="">\n	<ui:define name="header">\n	    Add your header here or delete to use the default\n	</ui:define>\n	<ui:define name="content">\n	    Add your content here or delete to use the default\n	</ui:define>\n	<ui:define name="footer">\n	    Add your footer here or delete to use the default\n	</ui:define>\n</ui:composition>\n</html>
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/templates/templates.xml b/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/templates/templates.xml
deleted file mode 100644
index c5f4eb1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facelet.ui/templates/templates.xml
+++ /dev/null
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<templates>
-<template id="org.eclipse.jst.jsf.facelet.ui.new_simple_footer_xhtml" autoinsert="false" context="html_new" deleted="false" description="%New_Footer_Description" enabled="true" name="%New_Facelet_Footer">%New_Facelet_Footer.footer</template>
-<template id="org.eclipse.jst.jsf.facelet.ui.new_header_xhtml" autoinsert="false" context="html_new" deleted="false" description="%New_Facelet_Header_Description" enabled="true" name="%New_Facelet_Header">%New_Facelet_Header.header</template>
-<template id="org.eclipse.jst.jsf.facelet.ui.new_basic_template_xhtml" autoinsert="false" context="html_new" deleted="false" description="%New_Facelet_Template_Description" enabled="true" name="%New_Facelet_Template">%New_Facelet_Template.template</template>
-<template id="org.eclipse.jst.jsf.facelet.ui.new_basic_composition_xhtml" autoinsert="false" context="html_new" deleted="false" description="%New_Simple_Facelet_Composition_Page_Description" enabled="true" name="%New_Simple_Facelet_Composition_Page">%New_Simple_Facelet_Composition_Page.composition</template>
-</templates>
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/.classpath b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/.classpath
deleted file mode 100644
index eb95f1a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/.classpath
+++ /dev/null
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="facesconfig"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
-	<classpathentry kind="output" path="bin"/>
-</classpath>
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/.cvsignore b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/.cvsignore
deleted file mode 100644
index 96a949c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/.cvsignore
+++ /dev/null
@@ -1,4 +0,0 @@
-bin
-build.xml
-javaCompiler...args
-@dot
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/.project b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/.project
deleted file mode 100644
index 2b7e076..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/.project
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jst.jsf.facesconfig</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/jsf/plugins/org.eclipse.jst.jsf.facesconfig/.settings/org.eclipse.core.resources.prefs b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/.settings/org.eclipse.core.resources.prefs
deleted file mode 100644
index 2a4d55b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/.settings/org.eclipse.core.resources.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Sun May 27 16:03:03 EDT 2007
-eclipse.preferences.version=1
-encoding/<project>=ISO-8859-1
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/.settings/org.eclipse.jdt.core.prefs b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/.settings/org.eclipse.jdt.core.prefs
deleted file mode 100644
index 46bff72..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/.settings/org.eclipse.jdt.core.prefs
+++ /dev/null
@@ -1,88 +0,0 @@
-#Tue Mar 16 20:45:27 PDT 2010
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
-org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.5
-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.doc.comment.support=enabled
-org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.autoboxing=warning
-org.eclipse.jdt.core.compiler.problem.comparingIdentical=warning
-org.eclipse.jdt.core.compiler.problem.deadCode=warning
-org.eclipse.jdt.core.compiler.problem.deprecation=warning
-org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
-org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
-org.eclipse.jdt.core.compiler.problem.discouragedReference=ignore
-org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore
-org.eclipse.jdt.core.compiler.problem.fatalOptionalError=enabled
-org.eclipse.jdt.core.compiler.problem.fieldHiding=warning
-org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
-org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
-org.eclipse.jdt.core.compiler.problem.forbiddenReference=error
-org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
-org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
-org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=warning
-org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
-org.eclipse.jdt.core.compiler.problem.invalidJavadoc=error
-org.eclipse.jdt.core.compiler.problem.invalidJavadocTags=enabled
-org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef=disabled
-org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef=disabled
-org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=protected
-org.eclipse.jdt.core.compiler.problem.localVariableHiding=warning
-org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
-org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod=ignore
-org.eclipse.jdt.core.compiler.problem.missingJavadocComments=warning
-org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=protected
-org.eclipse.jdt.core.compiler.problem.missingJavadocTags=warning
-org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=protected
-org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotationForInterfaceMethodImplementation=enabled
-org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning
-org.eclipse.jdt.core.compiler.problem.missingSynchronizedOnInheritedMethod=ignore
-org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
-org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
-org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=warning
-org.eclipse.jdt.core.compiler.problem.nullReference=ignore
-org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
-org.eclipse.jdt.core.compiler.problem.parameterAssignment=ignore
-org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=warning
-org.eclipse.jdt.core.compiler.problem.potentialNullReference=ignore
-org.eclipse.jdt.core.compiler.problem.rawTypeReference=ignore
-org.eclipse.jdt.core.compiler.problem.redundantNullCheck=ignore
-org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=ignore
-org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
-org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
-org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled
-org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
-org.eclipse.jdt.core.compiler.problem.typeParameterHiding=ignore
-org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=ignore
-org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=error
-org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning
-org.eclipse.jdt.core.compiler.problem.unnecessaryElse=warning
-org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=warning
-org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=warning
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable=enabled
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference=enabled
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.unusedImport=error
-org.eclipse.jdt.core.compiler.problem.unusedLabel=warning
-org.eclipse.jdt.core.compiler.problem.unusedLocal=error
-org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation=ignore
-org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
-org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference=enabled
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
-org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=error
-org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
-org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.compiler.source=1.5
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/.settings/org.eclipse.jdt.ui.prefs b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/.settings/org.eclipse.jdt.ui.prefs
deleted file mode 100644
index 82eb6c1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/.settings/org.eclipse.jdt.ui.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Fri Apr 06 18:25:15 PDT 2007
-eclipse.preferences.version=1
-org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><templates/>
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/.settings/org.eclipse.pde.prefs b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/.settings/org.eclipse.pde.prefs
deleted file mode 100644
index 669d251..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/.settings/org.eclipse.pde.prefs
+++ /dev/null
@@ -1,22 +0,0 @@
-#Fri May 30 11:55:28 PDT 2008
-compilers.f.unresolved-features=1
-compilers.f.unresolved-plugins=1
-compilers.incompatible-environment=1
-compilers.p.build=1
-compilers.p.deprecated=1
-compilers.p.discouraged-class=1
-compilers.p.internal=1
-compilers.p.missing-packages=0
-compilers.p.no-required-att=0
-compilers.p.not-externalized-att=0
-compilers.p.unknown-attribute=1
-compilers.p.unknown-class=1
-compilers.p.unknown-element=1
-compilers.p.unknown-identifier=1
-compilers.p.unknown-resource=1
-compilers.p.unresolved-ex-points=0
-compilers.p.unresolved-import=0
-compilers.s.create-docs=false
-compilers.s.doc-folder=doc
-compilers.s.open-tags=1
-eclipse.preferences.version=1
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/META-INF/MANIFEST.MF b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/META-INF/MANIFEST.MF
deleted file mode 100644
index 2e4038f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,30 +0,0 @@
-Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
-Bundle-Name: %plugin.name
-Bundle-SymbolicName: org.eclipse.jst.jsf.facesconfig; singleton:=true
-Bundle-Version: 1.2.1.qualifier
-Bundle-Activator: org.eclipse.jst.jsf.facesconfig.FacesConfigPlugin$Implementation
-Bundle-Vendor: %plugin.provider
-Bundle-Localization: plugin
-Require-Bundle: org.eclipse.core.resources;bundle-version="[3.2.0,4.0.0)",
- org.eclipse.core.runtime;bundle-version="[3.2.0,4.0.0)",
- org.eclipse.jst.j2ee;bundle-version="[1.1.0,1.2.0)",
- org.eclipse.emf.ecore.xmi;bundle-version="[2.2.0,3.0.0)",
- org.eclipse.wst.common.emf;bundle-version="[1.1.103,2.0.0)",
- org.eclipse.emf.edit.ui;bundle-version="[2.2.0,3.0.0)",
- org.eclipse.wst.xml.core;bundle-version="[1.1.0,1.2.0)",
- org.eclipse.wst.common.uriresolver;bundle-version="[1.1.0,1.2.0)",
- org.eclipse.wst.sse.core;bundle-version="[1.1.0,1.2.0)",
- org.eclipse.wst.common.emfworkbench.integration;bundle-version="[1.1.0,2.0.0)",
- org.eclipse.jst.common.frameworks;bundle-version="[1.1.0,2.0.0)"
-Bundle-ActivationPolicy: lazy
-Export-Package: org.eclipse.jst.jsf.facesconfig,
- org.eclipse.jst.jsf.facesconfig.edit.provider,
- org.eclipse.jst.jsf.facesconfig.emf,
- org.eclipse.jst.jsf.facesconfig.emf.impl,
- org.eclipse.jst.jsf.facesconfig.emf.util,
- org.eclipse.jst.jsf.facesconfig.internal;x-internal:=true,
- org.eclipse.jst.jsf.facesconfig.internal.nls;x-internal:=true,
- org.eclipse.jst.jsf.facesconfig.internal.translator;x-internal:=true,
- org.eclipse.jst.jsf.facesconfig.util
-Bundle-RequiredExecutionEnvironment: J2SE-1.5
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/about.html b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/about.html
deleted file mode 100644
index 8e56059..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/about.html
+++ /dev/null
@@ -1,22 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<head>
-<title>About</title>
-<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
-</head>
-<body lang="EN-US">
-<h2>About This Content</h2>
- 
-<p>June, 2008</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 1.0 (&quot;EPL&quot;).  A copy of the EPL is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</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.</p>
-
-</body>
-</html>
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/build.properties b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/build.properties
deleted file mode 100644
index a8eeb89..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/build.properties
+++ /dev/null
@@ -1,24 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-
-
-bin.includes = .,\
-               model/,\
-               META-INF/,\
-               plugin.xml,\
-               plugin.properties,\
-               about.html,\
-               icons/
-jars.compile.order = .
-source.. = facesconfig/
-output.. = bin/
-javacSource=1.5
-javacTarget=1.5
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/FacesConfigPlugin.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/FacesConfigPlugin.java
deleted file mode 100644
index a13bdb0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/FacesConfigPlugin.java
+++ /dev/null
@@ -1,115 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig;
-
-import org.eclipse.emf.common.EMFPlugin;
-import org.eclipse.emf.common.util.ResourceLocator;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl;
-import org.eclipse.jst.jsf.facesconfig.util.FacesConfigResourceFactory;
-import org.osgi.framework.BundleContext;
-
-
-/**
- * This class should not be extended by clients.
- * 
- * The main plugin class to be used in the desktop.
- */
-public final class FacesConfigPlugin extends EMFPlugin {
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Editor id string.  TODO: broken?
-	 */
-	public static final String FACES_CONFIG_EDITOR_ID = "org.eclipse.jst.jsf.facesconfig.internal.presentation.FacesConfigEditor"; //$NON-NLS-1$
-
-	/**
-	 * The plugin instance
-	 */
-	public static final FacesConfigPlugin INSTANCE = new FacesConfigPlugin();
-	private static Implementation plugin;
-
-    private FacesConfigPlugin() {
-	    super(new ResourceLocator[] {});
-    }
-
-    public ResourceLocator getPluginResourceLocator() {
-      return plugin;
-    }
-
-    /**
-     * Returns the singleton instance of the Eclipse plugin.
-     * @return the singleton instance.
-     */
-    public static Implementation getPlugin() {
-      return plugin;
-    }
-
-    /**
-     * Returns the singleton instance of the Eclipse plugin.
-     * @param exception 
-     */
-    public static void write(Exception exception)
-    {
-      INSTANCE.log(exception);
-    }
-
-	/**
-	 * The actual implementation of the Eclipse <b>Plugin</b>.
-	 */
-	public final static class Implementation extends EMFPlugin.EclipsePlugin {
-		/**
-		 * Internal constructor
-		 */
-		public Implementation() {
-			super();
-			// Remember the static instance.
-			plugin = this;
-		}
-		public void start(BundleContext context) throws Exception {
-			super.start(context);
-			// Init Faces Config Package
-			FacesConfigPackageImpl.init();
-
-			getFacesconfigPackage();
-			
-			// TODO: XN: no sure whether this line is needed
-			FacesConfigResourceFactory.registerDtds();
-			
-			FacesConfigResourceFactory.register();
-		}
-
-		/**
-		 * @return The faces config package instance
-		 * TODO: used?
-		 */
-		public FacesConfigPackage getFacesconfigPackage() {
-			return FacesConfigPackage.eINSTANCE;
-		}
-		
-		/**
-		 * @return the faces config factory instance.
-		 * TODO: used?
-		 */
-		public FacesConfigFactory getFacesconfigFactory() {
-			return (FacesConfigFactory) getFacesconfigPackage().getEFactoryInstance();
-		}
-
-	}
-}
-
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/AbsoluteOrderingTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/AbsoluteOrderingTypeItemProvider.java
deleted file mode 100644
index 40c500f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/AbsoluteOrderingTypeItemProvider.java
+++ /dev/null
@@ -1,179 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.emf.edit.provider.ItemProviderAdapter;
-import org.eclipse.emf.edit.provider.ViewerNotification;
-import org.eclipse.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.AbsoluteOrderingType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.AbsoluteOrderingType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public class AbsoluteOrderingTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param adapterFactory 
-	 * @generated NOT
-	 */
-	public AbsoluteOrderingTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.ABSOLUTE_ORDERING_TYPE__NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.ABSOLUTE_ORDERING_TYPE__OTHERS);
-		}
-		return childrenFeatures;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 AbsoluteOrderingType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/AbsoluteOrderingType")); //$NON-NLS-1$
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		return getString("_UI_AbsoluteOrderingType_type"); //$NON-NLS-1$
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(AbsoluteOrderingType.class)) {
-			case FacesConfigPackage.ABSOLUTE_ORDERING_TYPE__NAME:
-			case FacesConfigPackage.ABSOLUTE_ORDERING_TYPE__OTHERS:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.ABSOLUTE_ORDERING_TYPE__NAME,
-				 FacesConfigFactory.eINSTANCE.createNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.ABSOLUTE_ORDERING_TYPE__OTHERS,
-				 FacesConfigFactory.eINSTANCE.createOrderingOthersType()));
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ActionListenerTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ActionListenerTypeItemProvider.java
deleted file mode 100644
index f27e6fd..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ActionListenerTypeItemProvider.java
+++ /dev/null
@@ -1,211 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.ActionListenerType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a
- * {@link org.eclipse.jst.jsf.facesconfig.emf.ActionListenerType} object. <!--
- * begin-user-doc --> 
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * 
- * @generated
- */
-@SuppressWarnings("nls")
-public class ActionListenerTypeItemProvider extends ItemProviderAdapter
-		implements IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!--begin-user-doc --> 
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ActionListenerTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc --> 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * @param object 
-	 * 
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ActionListenerType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ActionListenerType_textContent_feature", "_UI_ActionListenerType_type"),
-				 FacesConfigPackage.Literals.ACTION_LISTENER_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc>
-     * @param object
-	 * <!-- end-user-doc --> 
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ActionListenerType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ActionListenerType_id_feature", "_UI_ActionListenerType_type"),
-				 FacesConfigPackage.Literals.ACTION_LISTENER_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns ActionListenerType.gif.
-	 * <!-- begin-user-doc --> <!--
-	 * end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ActionListenerType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc
-	 * --> <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((ActionListenerType) object).getTextContent();
-		return label == null || label.length() == 0 ? getString("_UI_ActionListenerType_type")
-				: label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ActionListenerType.class)) {
-			case FacesConfigPackage.ACTION_LISTENER_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.ACTION_LISTENER_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_ActionListenerType_type"); //$NON-NLS-1$
-		}
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ApplicationExtensionTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ApplicationExtensionTypeItemProvider.java
deleted file mode 100644
index 59ddbc8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ApplicationExtensionTypeItemProvider.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.edit.provider.IEditingDomainItemProvider;
-import org.eclipse.emf.edit.provider.IItemLabelProvider;
-import org.eclipse.emf.edit.provider.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.jst.jsf.facesconfig.emf.ApplicationExtensionType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationExtensionType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public class ApplicationExtensionTypeItemProvider
-    extends ExtensionTypeItemProvider
-    implements	
-        IEditingDomainItemProvider,	
-        IStructuredItemContentProvider,	
-        ITreeItemContentProvider,	
-        IItemLabelProvider,	
-        IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    @SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ApplicationExtensionTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This returns ApplicationExtensionType.gif.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-    public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ApplicationExtensionType")); //$NON-NLS-1$
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-    public String getText(Object object) {
-		String label = ((ApplicationExtensionType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ApplicationExtensionType_type") : //$NON-NLS-1$
-			getString("_UI_ApplicationExtensionType_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
-	 */
-    public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-		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
-	 */
-    protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ApplicationFactoryTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ApplicationFactoryTypeItemProvider.java
deleted file mode 100644
index f2da630..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ApplicationFactoryTypeItemProvider.java
+++ /dev/null
@@ -1,214 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.ApplicationFactoryType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationFactoryType} object.
- * <!-- begin-user-doc --> 
- * @extends {@link ITableItemLabelProvider}
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ApplicationFactoryTypeItemProvider
-extends ItemProviderAdapter
-implements
-	IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc --> 
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ApplicationFactoryTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!--begin-user-doc --> 
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ApplicationFactoryType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ApplicationFactoryType_textContent_feature", "_UI_ApplicationFactoryType_type"),
-				 FacesConfigPackage.Literals.APPLICATION_FACTORY_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc --> 
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ApplicationFactoryType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ApplicationFactoryType_id_feature", "_UI_ApplicationFactoryType_type"),
-				 FacesConfigPackage.Literals.APPLICATION_FACTORY_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns ApplicationFactoryType.gif.
-	 * <!-- begin-user-doc --> <!--
-	 * end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ApplicationFactoryType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc
-	 * --> <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((ApplicationFactoryType) object).getTextContent();
-		return label == null || label.length() == 0 ? getString("_UI_ApplicationFactoryType_type")
-				: label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ApplicationFactoryType.class)) {
-			case FacesConfigPackage.APPLICATION_FACTORY_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.APPLICATION_FACTORY_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-
-	/**
-	 * @param object
-	 * @param columnIndex
-	 * @return the column image
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_ApplicationFactoryType_type"); //$NON-NLS-1$
-		}
-
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ApplicationTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ApplicationTypeItemProvider.java
deleted file mode 100644
index 85d5c1f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ApplicationTypeItemProvider.java
+++ /dev/null
@@ -1,388 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.ApplicationType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ApplicationTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ApplicationTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addELResolverPropertyDescriptor(object);
-			addSystemEventListenerPropertyDescriptor(object);
-			addResourceBundlePropertyDescriptor(object);
-			addApplicationExtensionPropertyDescriptor(object);
-			addDefaultValidatorsPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ApplicationType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ApplicationType_id_feature", "_UI_ApplicationType_type"),
-				 FacesConfigPackage.Literals.APPLICATION_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the EL Resolver feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addELResolverPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ApplicationType_eLResolver_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ApplicationType_eLResolver_feature", "_UI_ApplicationType_type"),
-				 FacesConfigPackage.Literals.APPLICATION_TYPE__EL_RESOLVER,
-				 true,
-				 false,
-				 true,
-				 null,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the System Event Listener feature.
-	 * <!-- begin-user-doc -->
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addSystemEventListenerPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ApplicationType_systemEventListener_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ApplicationType_systemEventListener_feature", "_UI_ApplicationType_type"),
-				 FacesConfigPackage.Literals.APPLICATION_TYPE__SYSTEM_EVENT_LISTENER,
-				 true,
-				 false,
-				 true,
-				 null,
-				 null,
-				 null));
-	}
-
-				/**
-	 * This adds a property descriptor for the Resource Bundle feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addResourceBundlePropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ApplicationType_resourceBundle_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ApplicationType_resourceBundle_feature", "_UI_ApplicationType_type"),
-				 FacesConfigPackage.Literals.APPLICATION_TYPE__RESOURCE_BUNDLE,
-				 true,
-				 false,
-				 true,
-				 null,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Application Extension feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addApplicationExtensionPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ApplicationType_applicationExtension_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ApplicationType_applicationExtension_feature", "_UI_ApplicationType_type"),
-				 FacesConfigPackage.Literals.APPLICATION_TYPE__APPLICATION_EXTENSION,
-				 true,
-				 false,
-				 true,
-				 null,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Default Validators feature.
-	 * <!-- begin-user-doc -->
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addDefaultValidatorsPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ApplicationType_defaultValidators_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ApplicationType_defaultValidators_feature", "_UI_ApplicationType_type"),
-				 FacesConfigPackage.Literals.APPLICATION_TYPE__DEFAULT_VALIDATORS,
-				 true,
-				 false,
-				 true,
-				 null,
-				 null,
-				 null));
-	}
-
-				/**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.APPLICATION_TYPE__ACTION_LISTENER);
-			childrenFeatures.add(FacesConfigPackage.Literals.APPLICATION_TYPE__DEFAULT_RENDER_KIT_ID);
-			childrenFeatures.add(FacesConfigPackage.Literals.APPLICATION_TYPE__MESSAGE_BUNDLE);
-			childrenFeatures.add(FacesConfigPackage.Literals.APPLICATION_TYPE__NAVIGATION_HANDLER);
-			childrenFeatures.add(FacesConfigPackage.Literals.APPLICATION_TYPE__VIEW_HANDLER);
-			childrenFeatures.add(FacesConfigPackage.Literals.APPLICATION_TYPE__STATE_MANAGER);
-			childrenFeatures.add(FacesConfigPackage.Literals.APPLICATION_TYPE__PROPERTY_RESOLVER);
-			childrenFeatures.add(FacesConfigPackage.Literals.APPLICATION_TYPE__VARIABLE_RESOLVER);
-			childrenFeatures.add(FacesConfigPackage.Literals.APPLICATION_TYPE__RESOURCE_HANDLER);
-			childrenFeatures.add(FacesConfigPackage.Literals.APPLICATION_TYPE__LOCALE_CONFIG);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 ApplicationType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ApplicationType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((ApplicationType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ApplicationType_type") :
-			getString("_UI_ApplicationType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ApplicationType.class)) {
-			case FacesConfigPackage.APPLICATION_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__ACTION_LISTENER:
-			case FacesConfigPackage.APPLICATION_TYPE__DEFAULT_RENDER_KIT_ID:
-			case FacesConfigPackage.APPLICATION_TYPE__MESSAGE_BUNDLE:
-			case FacesConfigPackage.APPLICATION_TYPE__NAVIGATION_HANDLER:
-			case FacesConfigPackage.APPLICATION_TYPE__VIEW_HANDLER:
-			case FacesConfigPackage.APPLICATION_TYPE__STATE_MANAGER:
-			case FacesConfigPackage.APPLICATION_TYPE__PROPERTY_RESOLVER:
-			case FacesConfigPackage.APPLICATION_TYPE__VARIABLE_RESOLVER:
-			case FacesConfigPackage.APPLICATION_TYPE__RESOURCE_HANDLER:
-			case FacesConfigPackage.APPLICATION_TYPE__LOCALE_CONFIG:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.APPLICATION_TYPE__ACTION_LISTENER,
-				 FacesConfigFactory.eINSTANCE.createActionListenerType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.APPLICATION_TYPE__DEFAULT_RENDER_KIT_ID,
-				 FacesConfigFactory.eINSTANCE.createDefaultRenderKitIdType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.APPLICATION_TYPE__MESSAGE_BUNDLE,
-				 FacesConfigFactory.eINSTANCE.createMessageBundleType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.APPLICATION_TYPE__NAVIGATION_HANDLER,
-				 FacesConfigFactory.eINSTANCE.createNavigationHandlerType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.APPLICATION_TYPE__VIEW_HANDLER,
-				 FacesConfigFactory.eINSTANCE.createViewHandlerType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.APPLICATION_TYPE__STATE_MANAGER,
-				 FacesConfigFactory.eINSTANCE.createStateManagerType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.APPLICATION_TYPE__PROPERTY_RESOLVER,
-				 FacesConfigFactory.eINSTANCE.createPropertyResolverType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.APPLICATION_TYPE__VARIABLE_RESOLVER,
-				 FacesConfigFactory.eINSTANCE.createVariableResolverType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.APPLICATION_TYPE__RESOURCE_HANDLER,
-				 FacesConfigFactory.eINSTANCE.createResourceHandlerType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.APPLICATION_TYPE__LOCALE_CONFIG,
-				 FacesConfigFactory.eINSTANCE.createLocaleConfigType()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/AttributeClassTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/AttributeClassTypeItemProvider.java
deleted file mode 100644
index a920fda..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/AttributeClassTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.AttributeClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.AttributeClassType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class AttributeClassTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public AttributeClassTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_AttributeClassType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_AttributeClassType_textContent_feature", "_UI_AttributeClassType_type"),
-				 FacesConfigPackage.Literals.ATTRIBUTE_CLASS_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_AttributeClassType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_AttributeClassType_id_feature", "_UI_AttributeClassType_type"),
-				 FacesConfigPackage.Literals.ATTRIBUTE_CLASS_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns AttributeClassType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/AttributeClassType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((AttributeClassType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_AttributeClassType_type") :
-			getString("_UI_AttributeClassType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(AttributeClassType.class)) {
-			case FacesConfigPackage.ATTRIBUTE_CLASS_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.ATTRIBUTE_CLASS_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/AttributeExtensionTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/AttributeExtensionTypeItemProvider.java
deleted file mode 100644
index 3c77533..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/AttributeExtensionTypeItemProvider.java
+++ /dev/null
@@ -1,121 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.edit.provider.IEditingDomainItemProvider;
-import org.eclipse.emf.edit.provider.IItemLabelProvider;
-import org.eclipse.emf.edit.provider.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.jst.jsf.facesconfig.emf.AttributeExtensionType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.AttributeExtensionType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class AttributeExtensionTypeItemProvider
-	extends ExtensionTypeItemProvider
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public AttributeExtensionTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This returns AttributeExtensionType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/AttributeExtensionType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((AttributeExtensionType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_AttributeExtensionType_type") :
-			getString("_UI_AttributeExtensionType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-		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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/AttributeNameTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/AttributeNameTypeItemProvider.java
deleted file mode 100644
index 0cbbe4a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/AttributeNameTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.AttributeNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.AttributeNameType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class AttributeNameTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public AttributeNameTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_AttributeNameType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_AttributeNameType_textContent_feature", "_UI_AttributeNameType_type"),
-				 FacesConfigPackage.Literals.ATTRIBUTE_NAME_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_AttributeNameType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_AttributeNameType_id_feature", "_UI_AttributeNameType_type"),
-				 FacesConfigPackage.Literals.ATTRIBUTE_NAME_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns AttributeNameType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/AttributeNameType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((AttributeNameType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_AttributeNameType_type") :
-			getString("_UI_AttributeNameType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(AttributeNameType.class)) {
-			case FacesConfigPackage.ATTRIBUTE_NAME_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.ATTRIBUTE_NAME_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/AttributeTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/AttributeTypeItemProvider.java
deleted file mode 100644
index 8b3edb3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/AttributeTypeItemProvider.java
+++ /dev/null
@@ -1,281 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.AttributeType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * 
- */
-@SuppressWarnings("nls")
-public class AttributeTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource,
-		ITableItemLabelProvider{
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public AttributeTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_AttributeType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_AttributeType_id_feature", "_UI_AttributeType_type"),
-				 FacesConfigPackage.Literals.ATTRIBUTE_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.ATTRIBUTE_TYPE__DESCRIPTION);
-			childrenFeatures.add(FacesConfigPackage.Literals.ATTRIBUTE_TYPE__DISPLAY_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.ATTRIBUTE_TYPE__ICON);
-			childrenFeatures.add(FacesConfigPackage.Literals.ATTRIBUTE_TYPE__ATTRIBUTE_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.ATTRIBUTE_TYPE__ATTRIBUTE_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.ATTRIBUTE_TYPE__DEFAULT_VALUE);
-			childrenFeatures.add(FacesConfigPackage.Literals.ATTRIBUTE_TYPE__SUGGESTED_VALUE);
-			childrenFeatures.add(FacesConfigPackage.Literals.ATTRIBUTE_TYPE__ATTRIBUTE_EXTENSION);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 AttributeType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/AttributeType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((AttributeType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_AttributeType_type") :
-			getString("_UI_AttributeType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(AttributeType.class)) {
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.ATTRIBUTE_TYPE__DESCRIPTION:
-			case FacesConfigPackage.ATTRIBUTE_TYPE__DISPLAY_NAME:
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ICON:
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_NAME:
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_CLASS:
-			case FacesConfigPackage.ATTRIBUTE_TYPE__DEFAULT_VALUE:
-			case FacesConfigPackage.ATTRIBUTE_TYPE__SUGGESTED_VALUE:
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_EXTENSION:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.ATTRIBUTE_TYPE__DESCRIPTION,
-				 FacesConfigFactory.eINSTANCE.createDescriptionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.ATTRIBUTE_TYPE__DISPLAY_NAME,
-				 FacesConfigFactory.eINSTANCE.createDisplayNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.ATTRIBUTE_TYPE__ICON,
-				 FacesConfigFactory.eINSTANCE.createIconType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.ATTRIBUTE_TYPE__ATTRIBUTE_NAME,
-				 FacesConfigFactory.eINSTANCE.createAttributeNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.ATTRIBUTE_TYPE__ATTRIBUTE_CLASS,
-				 FacesConfigFactory.eINSTANCE.createAttributeClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.ATTRIBUTE_TYPE__DEFAULT_VALUE,
-				 FacesConfigFactory.eINSTANCE.createDefaultValueType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.ATTRIBUTE_TYPE__SUGGESTED_VALUE,
-				 FacesConfigFactory.eINSTANCE.createSuggestedValueType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.ATTRIBUTE_TYPE__ATTRIBUTE_EXTENSION,
-				 FacesConfigFactory.eINSTANCE.createAttributeExtensionType()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	public String getColumnText(Object object, int columnIndex) {
-		AttributeType attribute = (AttributeType) object;
-		switch (columnIndex) {
-
-		case 0:
-			return attribute.getAttributeName() == null ? "" : attribute //$NON-NLS-1$
-					.getAttributeName().getTextContent();
-		case 1:
-			return attribute.getAttributeClass() == null ? "" : attribute //$NON-NLS-1$
-					.getAttributeClass().getTextContent();
-		case 2:
-			return attribute.getDefaultValue() == null ? "" : attribute //$NON-NLS-1$
-					.getDefaultValue().getTextContent();
-		case 3:
-			return attribute.getSuggestedValue() == null ? "" : attribute //$NON-NLS-1$
-					.getSuggestedValue().getTextContent();
-		}
-		return null;
-	}
-
-	public Object getColumnImage(Object object, int columnIndex) {
-		// TODO Auto-generated method stub
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/BaseNameTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/BaseNameTypeItemProvider.java
deleted file mode 100644
index 5fbe1f2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/BaseNameTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.BaseNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.BaseNameType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class BaseNameTypeItemProvider
-    extends ItemProviderAdapter
-    implements	
-        IEditingDomainItemProvider,	
-        IStructuredItemContentProvider,	
-        ITreeItemContentProvider,	
-        IItemLabelProvider,	
-        IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public BaseNameTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_BaseNameType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_BaseNameType_textContent_feature", "_UI_BaseNameType_type"),
-				 FacesConfigPackage.Literals.BASE_NAME_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_BaseNameType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_BaseNameType_id_feature", "_UI_BaseNameType_type"),
-				 FacesConfigPackage.Literals.BASE_NAME_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns BaseNameType.gif.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/BaseNameType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getText(Object object) {
-		String label = ((BaseNameType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_BaseNameType_type") :
-			getString("_UI_BaseNameType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-    public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(BaseNameType.class)) {
-			case FacesConfigPackage.BASE_NAME_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.BASE_NAME_TYPE__ID:
-				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
-	 */
-    protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/BehaviorClassTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/BehaviorClassTypeItemProvider.java
deleted file mode 100644
index 12a7b9c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/BehaviorClassTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.BehaviorClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorClassType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class BehaviorClassTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * 	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public BehaviorClassTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_BehaviorClassType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_BehaviorClassType_textContent_feature", "_UI_BehaviorClassType_type"),
-				 FacesConfigPackage.Literals.BEHAVIOR_CLASS_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-	 * @param object  
-	 * <!-- end-user-doc --> 
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_BehaviorClassType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_BehaviorClassType_id_feature", "_UI_BehaviorClassType_type"),
-				 FacesConfigPackage.Literals.BEHAVIOR_CLASS_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This returns BehaviorClassType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/BehaviorClassType"));
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((BehaviorClassType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_BehaviorClassType_type") :
-			getString("_UI_BehaviorClassType_type") + " " + label;
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(BehaviorClassType.class)) {
-			case FacesConfigPackage.BEHAVIOR_CLASS_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.BEHAVIOR_CLASS_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/BehaviorExtensionTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/BehaviorExtensionTypeItemProvider.java
deleted file mode 100644
index 0e7a513..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/BehaviorExtensionTypeItemProvider.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.edit.provider.IEditingDomainItemProvider;
-import org.eclipse.emf.edit.provider.IItemLabelProvider;
-import org.eclipse.emf.edit.provider.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.jst.jsf.facesconfig.emf.BehaviorExtensionType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorExtensionType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public class BehaviorExtensionTypeItemProvider
-	extends ExtensionTypeItemProvider
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public BehaviorExtensionTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This returns BehaviorExtensionType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/BehaviorExtensionType")); //$NON-NLS-1$
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((BehaviorExtensionType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_BehaviorExtensionType_type") : //$NON-NLS-1$
-			getString("_UI_BehaviorExtensionType_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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-		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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/BehaviorIdTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/BehaviorIdTypeItemProvider.java
deleted file mode 100644
index b6fe2d1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/BehaviorIdTypeItemProvider.java
+++ /dev/null
@@ -1,193 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.BehaviorIdType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorIdType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class BehaviorIdTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-
-	 * @generated
-	 */
-	public BehaviorIdTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_BehaviorIdType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_BehaviorIdType_textContent_feature", "_UI_BehaviorIdType_type"),
-				 FacesConfigPackage.Literals.BEHAVIOR_ID_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_BehaviorIdType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_BehaviorIdType_id_feature", "_UI_BehaviorIdType_type"),
-				 FacesConfigPackage.Literals.BEHAVIOR_ID_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This returns BehaviorIdType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/BehaviorIdType")); //$NON-NLS-1$
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((BehaviorIdType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_BehaviorIdType_type") : //$NON-NLS-1$
-			getString("_UI_BehaviorIdType_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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(BehaviorIdType.class)) {
-			case FacesConfigPackage.BEHAVIOR_ID_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.BEHAVIOR_ID_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/BehaviorTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/BehaviorTypeItemProvider.java
deleted file mode 100644
index 1deaa16..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/BehaviorTypeItemProvider.java
+++ /dev/null
@@ -1,221 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.emf.edit.provider.ItemProviderAdapter;
-import org.eclipse.emf.edit.provider.ViewerNotification;
-import org.eclipse.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.BehaviorType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public class BehaviorTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public BehaviorTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.BEHAVIOR_TYPE__DESCRIPTION);
-			childrenFeatures.add(FacesConfigPackage.Literals.BEHAVIOR_TYPE__DISPLAY_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.BEHAVIOR_TYPE__ICON);
-			childrenFeatures.add(FacesConfigPackage.Literals.BEHAVIOR_TYPE__BEHAVIOR_ID);
-			childrenFeatures.add(FacesConfigPackage.Literals.BEHAVIOR_TYPE__BEHAVIOR_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.BEHAVIOR_TYPE__ATTRIBUTE);
-			childrenFeatures.add(FacesConfigPackage.Literals.BEHAVIOR_TYPE__PROPERTY);
-			childrenFeatures.add(FacesConfigPackage.Literals.BEHAVIOR_TYPE__BEHAVIOR_EXTENSION);
-		}
-		return childrenFeatures;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 BehaviorType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/BehaviorType")); //$NON-NLS-1$
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		return getString("_UI_BehaviorType_type"); //$NON-NLS-1$
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(BehaviorType.class)) {
-			case FacesConfigPackage.BEHAVIOR_TYPE__DESCRIPTION:
-			case FacesConfigPackage.BEHAVIOR_TYPE__DISPLAY_NAME:
-			case FacesConfigPackage.BEHAVIOR_TYPE__ICON:
-			case FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_ID:
-			case FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_CLASS:
-			case FacesConfigPackage.BEHAVIOR_TYPE__ATTRIBUTE:
-			case FacesConfigPackage.BEHAVIOR_TYPE__PROPERTY:
-			case FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_EXTENSION:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.BEHAVIOR_TYPE__DESCRIPTION,
-				 FacesConfigFactory.eINSTANCE.createDescriptionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.BEHAVIOR_TYPE__DISPLAY_NAME,
-				 FacesConfigFactory.eINSTANCE.createDisplayNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.BEHAVIOR_TYPE__ICON,
-				 FacesConfigFactory.eINSTANCE.createIconType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.BEHAVIOR_TYPE__BEHAVIOR_ID,
-				 FacesConfigFactory.eINSTANCE.createBehaviorIdType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.BEHAVIOR_TYPE__BEHAVIOR_CLASS,
-				 FacesConfigFactory.eINSTANCE.createBehaviorClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.BEHAVIOR_TYPE__ATTRIBUTE,
-				 FacesConfigFactory.eINSTANCE.createAttributeType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.BEHAVIOR_TYPE__PROPERTY,
-				 FacesConfigFactory.eINSTANCE.createPropertyType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.BEHAVIOR_TYPE__BEHAVIOR_EXTENSION,
-				 FacesConfigFactory.eINSTANCE.createBehaviorExtensionType()));
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ClientBehaviorRendererClassTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ClientBehaviorRendererClassTypeItemProvider.java
deleted file mode 100644
index b553b27..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ClientBehaviorRendererClassTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererClassType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ClientBehaviorRendererClassTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ClientBehaviorRendererClassTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ClientBehaviorRendererClassType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ClientBehaviorRendererClassType_textContent_feature", "_UI_ClientBehaviorRendererClassType_type"),
-				 FacesConfigPackage.Literals.CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc --> 
-	 * @param object
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ClientBehaviorRendererClassType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ClientBehaviorRendererClassType_id_feature", "_UI_ClientBehaviorRendererClassType_type"),
-				 FacesConfigPackage.Literals.CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This returns ClientBehaviorRendererClassType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ClientBehaviorRendererClassType"));
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((ClientBehaviorRendererClassType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ClientBehaviorRendererClassType_type") :
-			getString("_UI_ClientBehaviorRendererClassType_type") + " " + label;
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ClientBehaviorRendererClassType.class)) {
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ClientBehaviorRendererTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ClientBehaviorRendererTypeItemProvider.java
deleted file mode 100644
index 04b041e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ClientBehaviorRendererTypeItemProvider.java
+++ /dev/null
@@ -1,179 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.emf.edit.provider.ItemProviderAdapter;
-import org.eclipse.emf.edit.provider.ViewerNotification;
-import org.eclipse.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public class ClientBehaviorRendererTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ClientBehaviorRendererTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_TYPE);
-			childrenFeatures.add(FacesConfigPackage.Literals.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_CLASS);
-		}
-		return childrenFeatures;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 ClientBehaviorRendererType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ClientBehaviorRendererType")); //$NON-NLS-1$
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		return getString("_UI_ClientBehaviorRendererType_type"); //$NON-NLS-1$
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ClientBehaviorRendererType.class)) {
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_TYPE:
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_CLASS:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_TYPE,
-				 FacesConfigFactory.eINSTANCE.createClientBehaviorRendererTypeType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_CLASS,
-				 FacesConfigFactory.eINSTANCE.createClientBehaviorRendererClassType()));
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ClientBehaviorRendererTypeTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ClientBehaviorRendererTypeTypeItemProvider.java
deleted file mode 100644
index 4133218..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ClientBehaviorRendererTypeTypeItemProvider.java
+++ /dev/null
@@ -1,193 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererTypeType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererTypeType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public class ClientBehaviorRendererTypeTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ClientBehaviorRendererTypeTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * 
-	 * @generated NOT
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ClientBehaviorRendererTypeType_textContent_feature"), //$NON-NLS-1$
-				 getString("_UI_PropertyDescriptor_description", "_UI_ClientBehaviorRendererTypeType_textContent_feature", "_UI_ClientBehaviorRendererTypeType_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-				 FacesConfigPackage.Literals.CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc -->
-	 *  
-	 * @generated NOT
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ClientBehaviorRendererTypeType_id_feature"), //$NON-NLS-1$
-				 getString("_UI_PropertyDescriptor_description", "_UI_ClientBehaviorRendererTypeType_id_feature", "_UI_ClientBehaviorRendererTypeType_type"),  //$NON-NLS-1$ //$NON-NLS-2$//$NON-NLS-3$
-				 FacesConfigPackage.Literals.CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This returns ClientBehaviorRendererTypeType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ClientBehaviorRendererTypeType")); //$NON-NLS-1$
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((ClientBehaviorRendererTypeType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ClientBehaviorRendererTypeType_type") : //$NON-NLS-1$
-			getString("_UI_ClientBehaviorRendererTypeType_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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ClientBehaviorRendererTypeType.class)) {
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ComponentClassTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ComponentClassTypeItemProvider.java
deleted file mode 100644
index f5011bf..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ComponentClassTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.ComponentClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ComponentClassType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ComponentClassTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ComponentClassTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ComponentClassType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ComponentClassType_textContent_feature", "_UI_ComponentClassType_type"),
-				 FacesConfigPackage.Literals.COMPONENT_CLASS_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ComponentClassType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ComponentClassType_id_feature", "_UI_ComponentClassType_type"),
-				 FacesConfigPackage.Literals.COMPONENT_CLASS_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns ComponentClassType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ComponentClassType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((ComponentClassType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ComponentClassType_type") :
-			getString("_UI_ComponentClassType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ComponentClassType.class)) {
-			case FacesConfigPackage.COMPONENT_CLASS_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.COMPONENT_CLASS_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ComponentExtensionTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ComponentExtensionTypeItemProvider.java
deleted file mode 100644
index 90ae0fe..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ComponentExtensionTypeItemProvider.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.edit.provider.IEditingDomainItemProvider;
-import org.eclipse.emf.edit.provider.IItemLabelProvider;
-import org.eclipse.emf.edit.provider.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.jst.jsf.facesconfig.emf.ComponentExtensionType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ComponentExtensionType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public class ComponentExtensionTypeItemProvider
-	extends ExtensionTypeItemProvider
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ComponentExtensionTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This returns ComponentExtensionType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ComponentExtensionType")); //$NON-NLS-1$
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((ComponentExtensionType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ComponentExtensionType_type") : //$NON-NLS-1$
-			getString("_UI_ComponentExtensionType_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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-		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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ComponentFamilyTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ComponentFamilyTypeItemProvider.java
deleted file mode 100644
index 2865fff..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ComponentFamilyTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.ComponentFamilyType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ComponentFamilyType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ComponentFamilyTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ComponentFamilyTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ComponentFamilyType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ComponentFamilyType_textContent_feature", "_UI_ComponentFamilyType_type"),
-				 FacesConfigPackage.Literals.COMPONENT_FAMILY_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ComponentFamilyType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ComponentFamilyType_id_feature", "_UI_ComponentFamilyType_type"),
-				 FacesConfigPackage.Literals.COMPONENT_FAMILY_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns ComponentFamilyType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ComponentFamilyType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((ComponentFamilyType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ComponentFamilyType_type") :
-			getString("_UI_ComponentFamilyType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ComponentFamilyType.class)) {
-			case FacesConfigPackage.COMPONENT_FAMILY_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.COMPONENT_FAMILY_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ComponentTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ComponentTypeItemProvider.java
deleted file mode 100644
index c823f2e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ComponentTypeItemProvider.java
+++ /dev/null
@@ -1,322 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.ComponentType;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType} object.
- * <!-- begin-user-doc --> 
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-public class ComponentTypeItemProvider extends ItemProviderAdapter implements
-		IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * @param adapterFactory 
-	 * 
-	 * @generated
-	 */
-	public ComponentTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc --> 
-	 * 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * @param object
-	 */
-	protected void addComponentClassPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add(createItemPropertyDescriptor(
-				((ComposeableAdapterFactory) adapterFactory)
-						.getRootAdapterFactory(), getResourceLocator(),
-				getString("_UI_ComponentType_componentClass_feature"), //$NON-NLS-1$
-				getString("_UI_PropertyDescriptor_description", //$NON-NLS-1$
-						"_UI_ComponentType_componentClass_feature", //$NON-NLS-1$
-						"_UI_ComponentType_type"), FacesConfigPackage.eINSTANCE //$NON-NLS-1$
-						.getComponentType_ComponentClass(), true, null, null,
-				null));
-	}
-	
-	/**
-	 * @param object
-	 */
-	protected void addComponentTypePropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add(createItemPropertyDescriptor(
-				((ComposeableAdapterFactory) adapterFactory)
-						.getRootAdapterFactory(), getResourceLocator(),
-				getString("_UI_ComponentType_componentType_feature"), //$NON-NLS-1$
-				getString("_UI_PropertyDescriptor_description", //$NON-NLS-1$
-						"_UI_ComponentType_componentType_feature", //$NON-NLS-1$
-						"_UI_ComponentType_type"), FacesConfigPackage.eINSTANCE //$NON-NLS-1$
-						.getComponentType_ComponentType(), true, null, null,
-				null));
-	}
-	
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc --> 
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ComponentType_id_feature"), //$NON-NLS-1$
-				 getString("_UI_PropertyDescriptor_description", "_UI_ComponentType_id_feature", "_UI_ComponentType_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-				 FacesConfigPackage.Literals.COMPONENT_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.COMPONENT_TYPE__DESCRIPTION);
-			childrenFeatures.add(FacesConfigPackage.Literals.COMPONENT_TYPE__DISPLAY_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.COMPONENT_TYPE__ICON);
-			childrenFeatures.add(FacesConfigPackage.Literals.COMPONENT_TYPE__COMPONENT_TYPE);
-			childrenFeatures.add(FacesConfigPackage.Literals.COMPONENT_TYPE__COMPONENT_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.COMPONENT_TYPE__FACET);
-			childrenFeatures.add(FacesConfigPackage.Literals.COMPONENT_TYPE__ATTRIBUTE);
-			childrenFeatures.add(FacesConfigPackage.Literals.COMPONENT_TYPE__PROPERTY);
-			childrenFeatures.add(FacesConfigPackage.Literals.COMPONENT_TYPE__COMPONENT_EXTENSION);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 ComponentType.gif. <!-- begin-user-doc --> <!-- end-user-doc
-	 * -->
-	 * 
-	 * @generated NOT
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ComponentType")); //$NON-NLS-1$
-	}
-
-	/**
-	 * This returns the label text for the adapted class. <!-- begin-user-doc
-	 * --> <!-- end-user-doc -->
-	 * @generated NOT
-	 * 
-	 */
-	public String getText(Object object) {
-		String label = null;
-		if (((ComponentType) object).getDisplayName() != null
-				&& ((ComponentType) object).getDisplayName().size() > 0) {
-			label = ((DisplayNameType) ((ComponentType) object)
-					.getDisplayName().get(0)).getTextContent();
-		}
-
-		if (label == null || label.length() == 0) {
-			if (((ComponentType) object).getComponentClass() != null) {
-				label = ((ComponentType) object).getComponentClass()
-						.getTextContent();
-			}
-		}
-		
-		return label == null || label.length() == 0 ? getString("_UI_ComponentType_type") //$NON-NLS-1$
-				: label;
-//				: getString("_UI_ComponentType_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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ComponentType.class)) {
-			case FacesConfigPackage.COMPONENT_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.COMPONENT_TYPE__DESCRIPTION:
-			case FacesConfigPackage.COMPONENT_TYPE__DISPLAY_NAME:
-			case FacesConfigPackage.COMPONENT_TYPE__ICON:
-			case FacesConfigPackage.COMPONENT_TYPE__COMPONENT_TYPE:
-			case FacesConfigPackage.COMPONENT_TYPE__COMPONENT_CLASS:
-			case FacesConfigPackage.COMPONENT_TYPE__FACET:
-			case FacesConfigPackage.COMPONENT_TYPE__ATTRIBUTE:
-			case FacesConfigPackage.COMPONENT_TYPE__PROPERTY:
-			case FacesConfigPackage.COMPONENT_TYPE__COMPONENT_EXTENSION:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.COMPONENT_TYPE__DESCRIPTION,
-				 FacesConfigFactory.eINSTANCE.createDescriptionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.COMPONENT_TYPE__DISPLAY_NAME,
-				 FacesConfigFactory.eINSTANCE.createDisplayNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.COMPONENT_TYPE__ICON,
-				 FacesConfigFactory.eINSTANCE.createIconType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.COMPONENT_TYPE__COMPONENT_TYPE,
-				 FacesConfigFactory.eINSTANCE.createComponentTypeType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.COMPONENT_TYPE__COMPONENT_CLASS,
-				 FacesConfigFactory.eINSTANCE.createComponentClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.COMPONENT_TYPE__FACET,
-				 FacesConfigFactory.eINSTANCE.createFacetType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.COMPONENT_TYPE__ATTRIBUTE,
-				 FacesConfigFactory.eINSTANCE.createAttributeType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.COMPONENT_TYPE__PROPERTY,
-				 FacesConfigFactory.eINSTANCE.createPropertyType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.COMPONENT_TYPE__COMPONENT_EXTENSION,
-				 FacesConfigFactory.eINSTANCE.createComponentExtensionType()));
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		// TODO Auto-generated method stub
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_ComponentType_type"); //$NON-NLS-1$
-		}
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ComponentTypeTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ComponentTypeTypeItemProvider.java
deleted file mode 100644
index 20927a9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ComponentTypeTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.ComponentTypeType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ComponentTypeType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ComponentTypeTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ComponentTypeTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ComponentTypeType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ComponentTypeType_textContent_feature", "_UI_ComponentTypeType_type"),
-				 FacesConfigPackage.Literals.COMPONENT_TYPE_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ComponentTypeType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ComponentTypeType_id_feature", "_UI_ComponentTypeType_type"),
-				 FacesConfigPackage.Literals.COMPONENT_TYPE_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns ComponentTypeType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ComponentTypeType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((ComponentTypeType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ComponentTypeType_type") :
-			getString("_UI_ComponentTypeType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ComponentTypeType.class)) {
-			case FacesConfigPackage.COMPONENT_TYPE_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.COMPONENT_TYPE_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ConverterClassTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ConverterClassTypeItemProvider.java
deleted file mode 100644
index a9f940e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ConverterClassTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.ConverterClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ConverterClassType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ConverterClassTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConverterClassTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ConverterClassType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ConverterClassType_textContent_feature", "_UI_ConverterClassType_type"),
-				 FacesConfigPackage.Literals.CONVERTER_CLASS_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ConverterClassType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ConverterClassType_id_feature", "_UI_ConverterClassType_type"),
-				 FacesConfigPackage.Literals.CONVERTER_CLASS_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns ConverterClassType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ConverterClassType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((ConverterClassType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ConverterClassType_type") :
-			getString("_UI_ConverterClassType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ConverterClassType.class)) {
-			case FacesConfigPackage.CONVERTER_CLASS_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.CONVERTER_CLASS_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ConverterExtensionTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ConverterExtensionTypeItemProvider.java
deleted file mode 100644
index f0f5080..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ConverterExtensionTypeItemProvider.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.edit.provider.IEditingDomainItemProvider;
-import org.eclipse.emf.edit.provider.IItemLabelProvider;
-import org.eclipse.emf.edit.provider.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.jst.jsf.facesconfig.emf.ConverterExtensionType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ConverterExtensionType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public class ConverterExtensionTypeItemProvider
-    extends ExtensionTypeItemProvider
-    implements	
-        IEditingDomainItemProvider,	
-        IStructuredItemContentProvider,	
-        ITreeItemContentProvider,	
-        IItemLabelProvider,	
-        IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    @SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ConverterExtensionTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This returns ConverterExtensionType.gif.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-    public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ConverterExtensionType")); //$NON-NLS-1$
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-    public String getText(Object object) {
-		String label = ((ConverterExtensionType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ConverterExtensionType_type") : //$NON-NLS-1$
-			getString("_UI_ConverterExtensionType_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
-	 */
-    public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-		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
-	 */
-    protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ConverterForClassTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ConverterForClassTypeItemProvider.java
deleted file mode 100644
index 7539298..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ConverterForClassTypeItemProvider.java
+++ /dev/null
@@ -1,191 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.ConverterForClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ConverterForClassType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public class ConverterForClassTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConverterForClassTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ConverterForClassType_textContent_feature"), //$NON-NLS-1$
-				 getString("_UI_PropertyDescriptor_description", "_UI_ConverterForClassType_textContent_feature", "_UI_ConverterForClassType_type"),  //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
-				 FacesConfigPackage.Literals.CONVERTER_FOR_CLASS_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ConverterForClassType_id_feature"), //$NON-NLS-1$
-				 getString("_UI_PropertyDescriptor_description", "_UI_ConverterForClassType_id_feature", "_UI_ConverterForClassType_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-				 FacesConfigPackage.Literals.CONVERTER_FOR_CLASS_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns ConverterForClassType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ConverterForClassType")); //$NON-NLS-1$
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((ConverterForClassType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ConverterForClassType_type") : //$NON-NLS-1$
-			getString("_UI_ConverterForClassType_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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ConverterForClassType.class)) {
-			case FacesConfigPackage.CONVERTER_FOR_CLASS_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.CONVERTER_FOR_CLASS_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ConverterIdTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ConverterIdTypeItemProvider.java
deleted file mode 100644
index 7a5edf0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ConverterIdTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.ConverterIdType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ConverterIdType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ConverterIdTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConverterIdTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ConverterIdType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ConverterIdType_textContent_feature", "_UI_ConverterIdType_type"),
-				 FacesConfigPackage.Literals.CONVERTER_ID_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ConverterIdType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ConverterIdType_id_feature", "_UI_ConverterIdType_type"),
-				 FacesConfigPackage.Literals.CONVERTER_ID_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns ConverterIdType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ConverterIdType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((ConverterIdType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ConverterIdType_type") :
-			getString("_UI_ConverterIdType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ConverterIdType.class)) {
-			case FacesConfigPackage.CONVERTER_ID_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.CONVERTER_ID_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ConverterTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ConverterTypeItemProvider.java
deleted file mode 100644
index 1ad9ab6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ConverterTypeItemProvider.java
+++ /dev/null
@@ -1,297 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.ConverterType;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType} object.
- * <!-- begin-user-doc --> 
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ConverterTypeItemProvider extends ItemProviderAdapter implements
-		IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc --> 
- 	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConverterTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc --> 
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ConverterType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ConverterType_id_feature", "_UI_ConverterType_type"),
-				 FacesConfigPackage.Literals.CONVERTER_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.CONVERTER_TYPE__DESCRIPTION);
-			childrenFeatures.add(FacesConfigPackage.Literals.CONVERTER_TYPE__DISPLAY_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.CONVERTER_TYPE__ICON);
-			childrenFeatures.add(FacesConfigPackage.Literals.CONVERTER_TYPE__CONVERTER_ID);
-			childrenFeatures.add(FacesConfigPackage.Literals.CONVERTER_TYPE__CONVERTER_FOR_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.CONVERTER_TYPE__CONVERTER_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.CONVERTER_TYPE__ATTRIBUTE);
-			childrenFeatures.add(FacesConfigPackage.Literals.CONVERTER_TYPE__PROPERTY);
-			childrenFeatures.add(FacesConfigPackage.Literals.CONVERTER_TYPE__CONVERTER_EXTENSION);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 ConverterType.gif. <!-- begin-user-doc --> <!-- end-user-doc
-	 * -->
-	 * 
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ConverterType"));
-	}
-
-	/**
-	 * This returns the label text for the adapted class. <!-- begin-user-doc
-	 * --> <!-- end-user-doc -->
-	 * 
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = null;
-		
-		if (((ConverterType) object).getDisplayName() != null
-				&& ((ConverterType) object).getDisplayName().size() > 0) {
-			label = ((DisplayNameType) ((ConverterType) object)
-					.getDisplayName().get(0)).getTextContent();
-		}
-		
-		if (label == null && ((ConverterType) object).getConverterId() != null) {
-			label = ((ConverterType) object).getConverterId().getTextContent();
-		}
-
-		if (label == null || label.length() == 0) {
-			if (((ConverterType) object).getConverterClass() != null)
-				label = ((ConverterType) object).getConverterClass()
-						.getTextContent();
-		}
-		if (label == null || label.length() ==0) {
-			label = ((ConverterType) object).getId();
-		}
-
-		return label == null || label.length() == 0 ? getString("_UI_ConverterType_type") 
-				: label;
-//				: getString("_UI_ConverterType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ConverterType.class)) {
-			case FacesConfigPackage.CONVERTER_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.CONVERTER_TYPE__DESCRIPTION:
-			case FacesConfigPackage.CONVERTER_TYPE__DISPLAY_NAME:
-			case FacesConfigPackage.CONVERTER_TYPE__ICON:
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_ID:
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_FOR_CLASS:
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_CLASS:
-			case FacesConfigPackage.CONVERTER_TYPE__ATTRIBUTE:
-			case FacesConfigPackage.CONVERTER_TYPE__PROPERTY:
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_EXTENSION:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.CONVERTER_TYPE__DESCRIPTION,
-				 FacesConfigFactory.eINSTANCE.createDescriptionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.CONVERTER_TYPE__DISPLAY_NAME,
-				 FacesConfigFactory.eINSTANCE.createDisplayNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.CONVERTER_TYPE__ICON,
-				 FacesConfigFactory.eINSTANCE.createIconType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.CONVERTER_TYPE__CONVERTER_ID,
-				 FacesConfigFactory.eINSTANCE.createConverterIdType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.CONVERTER_TYPE__CONVERTER_FOR_CLASS,
-				 FacesConfigFactory.eINSTANCE.createConverterForClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.CONVERTER_TYPE__CONVERTER_CLASS,
-				 FacesConfigFactory.eINSTANCE.createConverterClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.CONVERTER_TYPE__ATTRIBUTE,
-				 FacesConfigFactory.eINSTANCE.createAttributeType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.CONVERTER_TYPE__PROPERTY,
-				 FacesConfigFactory.eINSTANCE.createPropertyType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.CONVERTER_TYPE__CONVERTER_EXTENSION,
-				 FacesConfigFactory.eINSTANCE.createConverterExtensionType()));
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_ConverterType_type"); //$NON-NLS-1$
-		}
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DefaultLocaleTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DefaultLocaleTypeItemProvider.java
deleted file mode 100644
index 8777aa4..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DefaultLocaleTypeItemProvider.java
+++ /dev/null
@@ -1,186 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.DefaultLocaleType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a
- * {@link org.eclipse.jst.jsf.facesconfig.emf.DefaultLocaleType} object. <!--
- * begin-user-doc --> <!-- end-user-doc -->
- * 
- * @generated
- */
-@SuppressWarnings("nls")
-public class DefaultLocaleTypeItemProvider extends ItemProviderAdapter
-		implements IEditingDomainItemProvider, IStructuredItemContentProvider,
-		ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc --> 
- 	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DefaultLocaleTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc --> 
- 	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_DefaultLocaleType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_DefaultLocaleType_textContent_feature", "_UI_DefaultLocaleType_type"),
-				 FacesConfigPackage.Literals.DEFAULT_LOCALE_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc --> 
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_DefaultLocaleType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_DefaultLocaleType_id_feature", "_UI_DefaultLocaleType_type"),
-				 FacesConfigPackage.Literals.DEFAULT_LOCALE_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns DefaultLocaleType.gif.
-	 * <!-- begin-user-doc --> <!--
-	 * end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/DefaultLocaleType"));
-	}
-
-    /**
-     * This returns the label text for the adapted class.
-     * <!-- begin-user-doc
-	 * --> <!-- end-user-doc -->
-     * @generated NOT
-     */
-	public String getText(Object object) {
-        String label = ((DefaultLocaleType)object).getTextContent();
-        return label == null || label.length() == 0 ?
-            getString("_UI_DefaultLocaleType_type") : //$NON-NLS-1$
-            label;
-    }
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(DefaultLocaleType.class)) {
-			case FacesConfigPackage.DEFAULT_LOCALE_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.DEFAULT_LOCALE_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DefaultRenderKitIdTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DefaultRenderKitIdTypeItemProvider.java
deleted file mode 100644
index 82efd15..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DefaultRenderKitIdTypeItemProvider.java
+++ /dev/null
@@ -1,208 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.DefaultRenderKitIdType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.DefaultRenderKitIdType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class DefaultRenderKitIdTypeItemProvider extends ItemProviderAdapter
-		implements IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc --> 
-	 * @param adapterFactory
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DefaultRenderKitIdTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_DefaultRenderKitIdType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_DefaultRenderKitIdType_textContent_feature", "_UI_DefaultRenderKitIdType_type"),
-				 FacesConfigPackage.Literals.DEFAULT_RENDER_KIT_ID_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc --> 
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_DefaultRenderKitIdType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_DefaultRenderKitIdType_id_feature", "_UI_DefaultRenderKitIdType_type"),
-				 FacesConfigPackage.Literals.DEFAULT_RENDER_KIT_ID_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns DefaultRenderKitIdType.gif.
-	 * <!-- begin-user-doc --> <!--
-	 * end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/DefaultRenderKitIdType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc
-	 * --> <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((DefaultRenderKitIdType) object).getTextContent();
-		return label == null || label.length() == 0 ? getString("_UI_DefaultRenderKitIdType_type")
-				: label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(DefaultRenderKitIdType.class)) {
-			case FacesConfigPackage.DEFAULT_RENDER_KIT_ID_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.DEFAULT_RENDER_KIT_ID_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_DefaultRenderKitIdType_type"); //$NON-NLS-1$
-		}
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DefaultValidatorsTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DefaultValidatorsTypeItemProvider.java
deleted file mode 100644
index 67afedd..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DefaultValidatorsTypeItemProvider.java
+++ /dev/null
@@ -1,205 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.DefaultValidatorsType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValidatorsType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class DefaultValidatorsTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DefaultValidatorsTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_DefaultValidatorsType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_DefaultValidatorsType_id_feature", "_UI_DefaultValidatorsType_type"),
-				 FacesConfigPackage.Literals.DEFAULT_VALIDATORS_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.DEFAULT_VALIDATORS_TYPE__VALIDATOR_ID);
-		}
-		return childrenFeatures;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 DefaultValidatorsType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/DefaultValidatorsType"));
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((DefaultValidatorsType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_DefaultValidatorsType_type") :
-			getString("_UI_DefaultValidatorsType_type") + " " + label;
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(DefaultValidatorsType.class)) {
-			case FacesConfigPackage.DEFAULT_VALIDATORS_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.DEFAULT_VALIDATORS_TYPE__VALIDATOR_ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DEFAULT_VALIDATORS_TYPE__VALIDATOR_ID,
-				 FacesConfigFactory.eINSTANCE.createValidatorIdType()));
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DefaultValueTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DefaultValueTypeItemProvider.java
deleted file mode 100644
index b830289..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DefaultValueTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.DefaultValueType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValueType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class DefaultValueTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DefaultValueTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_DefaultValueType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_DefaultValueType_textContent_feature", "_UI_DefaultValueType_type"),
-				 FacesConfigPackage.Literals.DEFAULT_VALUE_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_DefaultValueType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_DefaultValueType_id_feature", "_UI_DefaultValueType_type"),
-				 FacesConfigPackage.Literals.DEFAULT_VALUE_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns DefaultValueType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/DefaultValueType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((DefaultValueType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_DefaultValueType_type") :
-			getString("_UI_DefaultValueType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(DefaultValueType.class)) {
-			case FacesConfigPackage.DEFAULT_VALUE_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.DEFAULT_VALUE_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DescriptionTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DescriptionTypeItemProvider.java
deleted file mode 100644
index 4bf86c2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DescriptionTypeItemProvider.java
+++ /dev/null
@@ -1,217 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.DescriptionType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class DescriptionTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DescriptionTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addLangPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_DescriptionType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_DescriptionType_textContent_feature", "_UI_DescriptionType_type"),
-				 FacesConfigPackage.Literals.DESCRIPTION_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Lang feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addLangPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_DescriptionType_lang_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_DescriptionType_lang_feature", "_UI_DescriptionType_type"),
-				 FacesConfigPackage.Literals.DESCRIPTION_TYPE__LANG,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_DescriptionType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_DescriptionType_id_feature", "_UI_DescriptionType_type"),
-				 FacesConfigPackage.Literals.DESCRIPTION_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns DescriptionType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/DescriptionType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((DescriptionType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_DescriptionType_type") :
-			getString("_UI_DescriptionType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(DescriptionType.class)) {
-			case FacesConfigPackage.DESCRIPTION_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.DESCRIPTION_TYPE__LANG:
-			case FacesConfigPackage.DESCRIPTION_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DisplayNameTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DisplayNameTypeItemProvider.java
deleted file mode 100644
index 91d43b5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DisplayNameTypeItemProvider.java
+++ /dev/null
@@ -1,217 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class DisplayNameTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DisplayNameTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addLangPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_DisplayNameType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_DisplayNameType_textContent_feature", "_UI_DisplayNameType_type"),
-				 FacesConfigPackage.Literals.DISPLAY_NAME_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Lang feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addLangPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_DisplayNameType_lang_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_DisplayNameType_lang_feature", "_UI_DisplayNameType_type"),
-				 FacesConfigPackage.Literals.DISPLAY_NAME_TYPE__LANG,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc --> 
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_DisplayNameType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_DisplayNameType_id_feature", "_UI_DisplayNameType_type"),
-				 FacesConfigPackage.Literals.DISPLAY_NAME_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns DisplayNameType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/DisplayNameType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((DisplayNameType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_DisplayNameType_type") :
-			getString("_UI_DisplayNameType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(DisplayNameType.class)) {
-			case FacesConfigPackage.DISPLAY_NAME_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.DISPLAY_NAME_TYPE__LANG:
-			case FacesConfigPackage.DISPLAY_NAME_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DocumentRootItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DocumentRootItemProvider.java
deleted file mode 100644
index 09acd88..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DocumentRootItemProvider.java
+++ /dev/null
@@ -1,886 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.emf.edit.provider.ItemProviderAdapter;
-import org.eclipse.emf.edit.provider.ViewerNotification;
-import org.eclipse.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public class DocumentRootItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DocumentRootItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__ABSOLUTE_ORDERING);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__ACTION_LISTENER);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__APPLICATION);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__APPLICATION_FACTORY);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__ATTRIBUTE);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__ATTRIBUTE_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__ATTRIBUTE_EXTENSION);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__ATTRIBUTE_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__BEHAVIOR);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__BEHAVIOR_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__BEHAVIOR_ID);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__BEHAVIOR_EXTENSION);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT_EXTENSION);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT_FAMILY);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT_TYPE);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__CONVERTER);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__CONVERTER_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__CONVERTER_FOR_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__CONVERTER_ID);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__DEFAULT_LOCALE);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__DEFAULT_RENDER_KIT_ID);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__DEFAULT_VALIDATORS);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__DEFAULT_VALUE);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__DESCRIPTION);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__DISPLAY_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__EXCEPTION_HANDLER_FACTORY);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__EXTERNAL_CONTEXT_FACTORY);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACES_CONFIG);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACES_CONTEXT_FACTORY);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACET);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACET_EXTENSION);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACET_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACTORY);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__FROM_ACTION);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__FROM_OUTCOME);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__FROM_VIEW_ID);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__ICON);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__IF);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__KEY);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__KEY_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__LARGE_ICON);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__LIFECYCLE);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__LIFECYCLE_FACTORY);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__LIST_ENTRIES);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__LOCALE_CONFIG);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_BEAN);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_BEAN_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_BEAN_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_BEAN_SCOPE);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_PROPERTY);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__MAP_ENTRIES);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__MAP_ENTRY);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__MESSAGE_BUNDLE);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__NAVIGATION_CASE);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__NAVIGATION_HANDLER);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__NAVIGATION_RULE);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__NULL_VALUE);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__ORDERING);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__ORDERING_ORDERING);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__OTHERS);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__PARTIAL_VIEW_CONTEXT_FACTORY);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__PHASE_LISTENER);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY_EXTENSION);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY_RESOLVER);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__REDIRECT);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__REDIRECT_VIEW_PARAM);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__REFERENCED_BEAN);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__REFERENCED_BEAN_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__REFERENCED_BEAN_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDERER);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDERER_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDERER_EXTENSION);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDERER_TYPE);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDER_KIT);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDER_KIT_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDER_KIT_FACTORY);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDER_KIT_ID);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__RESOURCE_HANDLER);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__SMALL_ICON);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__SOURCE_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__STATE_MANAGER);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__SUGGESTED_VALUE);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__SUPPORTED_LOCALE);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__SYSTEM_EVENT_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__TAG_HANDLER_DELEGATE_FACTORY);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__TO_VIEW_ID);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALIDATOR);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALIDATOR_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALIDATOR_ID);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALUE);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALUE_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__VARIABLE_RESOLVER);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__VIEW_DECLARATION_LANGUAGE_FACTORY);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__VIEW_HANDLER);
-			childrenFeatures.add(FacesConfigPackage.Literals.DOCUMENT_ROOT__VISIT_CONTEXT_FACTORY);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 DocumentRoot.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/DocumentRoot")); //$NON-NLS-1$
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		return getString("_UI_DocumentRoot_type"); //$NON-NLS-1$
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(DocumentRoot.class)) {
-			case FacesConfigPackage.DOCUMENT_ROOT__ABSOLUTE_ORDERING:
-			case FacesConfigPackage.DOCUMENT_ROOT__ACTION_LISTENER:
-			case FacesConfigPackage.DOCUMENT_ROOT__APPLICATION:
-			case FacesConfigPackage.DOCUMENT_ROOT__APPLICATION_FACTORY:
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE:
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE_CLASS:
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE_EXTENSION:
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE_NAME:
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR:
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR_CLASS:
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR_ID:
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR_EXTENSION:
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT:
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_CLASS:
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_EXTENSION:
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_FAMILY:
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_TYPE:
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER:
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER_CLASS:
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER_FOR_CLASS:
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER_ID:
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_LOCALE:
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_RENDER_KIT_ID:
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_VALIDATORS:
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_VALUE:
-			case FacesConfigPackage.DOCUMENT_ROOT__DESCRIPTION:
-			case FacesConfigPackage.DOCUMENT_ROOT__DISPLAY_NAME:
-			case FacesConfigPackage.DOCUMENT_ROOT__EXCEPTION_HANDLER_FACTORY:
-			case FacesConfigPackage.DOCUMENT_ROOT__EXTERNAL_CONTEXT_FACTORY:
-			case FacesConfigPackage.DOCUMENT_ROOT__FACES_CONFIG:
-			case FacesConfigPackage.DOCUMENT_ROOT__FACES_CONTEXT_FACTORY:
-			case FacesConfigPackage.DOCUMENT_ROOT__FACET:
-			case FacesConfigPackage.DOCUMENT_ROOT__FACET_EXTENSION:
-			case FacesConfigPackage.DOCUMENT_ROOT__FACET_NAME:
-			case FacesConfigPackage.DOCUMENT_ROOT__FACTORY:
-			case FacesConfigPackage.DOCUMENT_ROOT__FROM_ACTION:
-			case FacesConfigPackage.DOCUMENT_ROOT__FROM_OUTCOME:
-			case FacesConfigPackage.DOCUMENT_ROOT__FROM_VIEW_ID:
-			case FacesConfigPackage.DOCUMENT_ROOT__ICON:
-			case FacesConfigPackage.DOCUMENT_ROOT__IF:
-			case FacesConfigPackage.DOCUMENT_ROOT__KEY:
-			case FacesConfigPackage.DOCUMENT_ROOT__KEY_CLASS:
-			case FacesConfigPackage.DOCUMENT_ROOT__LARGE_ICON:
-			case FacesConfigPackage.DOCUMENT_ROOT__LIFECYCLE:
-			case FacesConfigPackage.DOCUMENT_ROOT__LIFECYCLE_FACTORY:
-			case FacesConfigPackage.DOCUMENT_ROOT__LIST_ENTRIES:
-			case FacesConfigPackage.DOCUMENT_ROOT__LOCALE_CONFIG:
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN:
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN_CLASS:
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN_NAME:
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN_SCOPE:
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_PROPERTY:
-			case FacesConfigPackage.DOCUMENT_ROOT__MAP_ENTRIES:
-			case FacesConfigPackage.DOCUMENT_ROOT__MAP_ENTRY:
-			case FacesConfigPackage.DOCUMENT_ROOT__MESSAGE_BUNDLE:
-			case FacesConfigPackage.DOCUMENT_ROOT__NAME:
-			case FacesConfigPackage.DOCUMENT_ROOT__NAVIGATION_CASE:
-			case FacesConfigPackage.DOCUMENT_ROOT__NAVIGATION_HANDLER:
-			case FacesConfigPackage.DOCUMENT_ROOT__NAVIGATION_RULE:
-			case FacesConfigPackage.DOCUMENT_ROOT__NULL_VALUE:
-			case FacesConfigPackage.DOCUMENT_ROOT__ORDERING:
-			case FacesConfigPackage.DOCUMENT_ROOT__ORDERING_ORDERING:
-			case FacesConfigPackage.DOCUMENT_ROOT__OTHERS:
-			case FacesConfigPackage.DOCUMENT_ROOT__PARTIAL_VIEW_CONTEXT_FACTORY:
-			case FacesConfigPackage.DOCUMENT_ROOT__PHASE_LISTENER:
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY:
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_CLASS:
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_EXTENSION:
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_NAME:
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_RESOLVER:
-			case FacesConfigPackage.DOCUMENT_ROOT__REDIRECT:
-			case FacesConfigPackage.DOCUMENT_ROOT__REDIRECT_VIEW_PARAM:
-			case FacesConfigPackage.DOCUMENT_ROOT__REFERENCED_BEAN:
-			case FacesConfigPackage.DOCUMENT_ROOT__REFERENCED_BEAN_CLASS:
-			case FacesConfigPackage.DOCUMENT_ROOT__REFERENCED_BEAN_NAME:
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER:
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER_CLASS:
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER_EXTENSION:
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER_TYPE:
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT:
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT_CLASS:
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT_FACTORY:
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT_ID:
-			case FacesConfigPackage.DOCUMENT_ROOT__RESOURCE_HANDLER:
-			case FacesConfigPackage.DOCUMENT_ROOT__SMALL_ICON:
-			case FacesConfigPackage.DOCUMENT_ROOT__SOURCE_CLASS:
-			case FacesConfigPackage.DOCUMENT_ROOT__STATE_MANAGER:
-			case FacesConfigPackage.DOCUMENT_ROOT__SUGGESTED_VALUE:
-			case FacesConfigPackage.DOCUMENT_ROOT__SUPPORTED_LOCALE:
-			case FacesConfigPackage.DOCUMENT_ROOT__SYSTEM_EVENT_CLASS:
-			case FacesConfigPackage.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER:
-			case FacesConfigPackage.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER_CLASS:
-			case FacesConfigPackage.DOCUMENT_ROOT__TAG_HANDLER_DELEGATE_FACTORY:
-			case FacesConfigPackage.DOCUMENT_ROOT__TO_VIEW_ID:
-			case FacesConfigPackage.DOCUMENT_ROOT__VALIDATOR:
-			case FacesConfigPackage.DOCUMENT_ROOT__VALIDATOR_CLASS:
-			case FacesConfigPackage.DOCUMENT_ROOT__VALIDATOR_ID:
-			case FacesConfigPackage.DOCUMENT_ROOT__VALUE:
-			case FacesConfigPackage.DOCUMENT_ROOT__VALUE_CLASS:
-			case FacesConfigPackage.DOCUMENT_ROOT__VARIABLE_RESOLVER:
-			case FacesConfigPackage.DOCUMENT_ROOT__VIEW_DECLARATION_LANGUAGE_FACTORY:
-			case FacesConfigPackage.DOCUMENT_ROOT__VIEW_HANDLER:
-			case FacesConfigPackage.DOCUMENT_ROOT__VISIT_CONTEXT_FACTORY:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__ABSOLUTE_ORDERING,
-				 FacesConfigFactory.eINSTANCE.createAbsoluteOrderingType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__ACTION_LISTENER,
-				 FacesConfigFactory.eINSTANCE.createActionListenerType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__APPLICATION,
-				 FacesConfigFactory.eINSTANCE.createApplicationType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__APPLICATION_FACTORY,
-				 FacesConfigFactory.eINSTANCE.createApplicationFactoryType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__ATTRIBUTE,
-				 FacesConfigFactory.eINSTANCE.createAttributeType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__ATTRIBUTE_CLASS,
-				 FacesConfigFactory.eINSTANCE.createAttributeClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__ATTRIBUTE_EXTENSION,
-				 FacesConfigFactory.eINSTANCE.createAttributeExtensionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__ATTRIBUTE_NAME,
-				 FacesConfigFactory.eINSTANCE.createAttributeNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__BEHAVIOR,
-				 FacesConfigFactory.eINSTANCE.createBehaviorType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__BEHAVIOR_CLASS,
-				 FacesConfigFactory.eINSTANCE.createBehaviorClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__BEHAVIOR_ID,
-				 FacesConfigFactory.eINSTANCE.createBehaviorIdType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__BEHAVIOR_EXTENSION,
-				 FacesConfigFactory.eINSTANCE.createBehaviorExtensionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT,
-				 FacesConfigFactory.eINSTANCE.createComponentType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT_CLASS,
-				 FacesConfigFactory.eINSTANCE.createComponentClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT_EXTENSION,
-				 FacesConfigFactory.eINSTANCE.createComponentExtensionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT_FAMILY,
-				 FacesConfigFactory.eINSTANCE.createComponentFamilyType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT_TYPE,
-				 FacesConfigFactory.eINSTANCE.createComponentTypeType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__CONVERTER,
-				 FacesConfigFactory.eINSTANCE.createConverterType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__CONVERTER_CLASS,
-				 FacesConfigFactory.eINSTANCE.createConverterClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__CONVERTER_FOR_CLASS,
-				 FacesConfigFactory.eINSTANCE.createConverterForClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__CONVERTER_ID,
-				 FacesConfigFactory.eINSTANCE.createConverterIdType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__DEFAULT_LOCALE,
-				 FacesConfigFactory.eINSTANCE.createDefaultLocaleType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__DEFAULT_RENDER_KIT_ID,
-				 FacesConfigFactory.eINSTANCE.createDefaultRenderKitIdType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__DEFAULT_VALIDATORS,
-				 FacesConfigFactory.eINSTANCE.createDefaultValidatorsType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__DEFAULT_VALUE,
-				 FacesConfigFactory.eINSTANCE.createDefaultValueType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__DESCRIPTION,
-				 FacesConfigFactory.eINSTANCE.createDescriptionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__DISPLAY_NAME,
-				 FacesConfigFactory.eINSTANCE.createDisplayNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__EXCEPTION_HANDLER_FACTORY,
-				 FacesConfigFactory.eINSTANCE.createExceptionHandlerFactoryType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__EXTERNAL_CONTEXT_FACTORY,
-				 FacesConfigFactory.eINSTANCE.createExternalContextFactoryType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACES_CONFIG,
-				 FacesConfigFactory.eINSTANCE.createFacesConfigType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACES_CONTEXT_FACTORY,
-				 FacesConfigFactory.eINSTANCE.createFacesContextFactoryType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACET,
-				 FacesConfigFactory.eINSTANCE.createFacetType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACET_EXTENSION,
-				 FacesConfigFactory.eINSTANCE.createFacetExtensionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACET_NAME,
-				 FacesConfigFactory.eINSTANCE.createFacetNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACTORY,
-				 FacesConfigFactory.eINSTANCE.createFactoryType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__FROM_ACTION,
-				 FacesConfigFactory.eINSTANCE.createFromActionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__FROM_OUTCOME,
-				 FacesConfigFactory.eINSTANCE.createFromOutcomeType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__FROM_VIEW_ID,
-				 FacesConfigFactory.eINSTANCE.createFromViewIdType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__ICON,
-				 FacesConfigFactory.eINSTANCE.createIconType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__IF,
-				 FacesConfigFactory.eINSTANCE.createIfType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__KEY,
-				 FacesConfigFactory.eINSTANCE.createKeyType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__KEY_CLASS,
-				 FacesConfigFactory.eINSTANCE.createKeyClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__LARGE_ICON,
-				 FacesConfigFactory.eINSTANCE.createLargeIconType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__LIFECYCLE,
-				 FacesConfigFactory.eINSTANCE.createLifecycleType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__LIFECYCLE_FACTORY,
-				 FacesConfigFactory.eINSTANCE.createLifecycleFactoryType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__LIST_ENTRIES,
-				 FacesConfigFactory.eINSTANCE.createListEntriesType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__LOCALE_CONFIG,
-				 FacesConfigFactory.eINSTANCE.createLocaleConfigType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_BEAN,
-				 FacesConfigFactory.eINSTANCE.createManagedBeanType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_BEAN_CLASS,
-				 FacesConfigFactory.eINSTANCE.createManagedBeanClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_BEAN_NAME,
-				 FacesConfigFactory.eINSTANCE.createManagedBeanNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_BEAN_SCOPE,
-				 FacesConfigFactory.eINSTANCE.createManagedBeanScopeType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_PROPERTY,
-				 FacesConfigFactory.eINSTANCE.createManagedPropertyType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__MAP_ENTRIES,
-				 FacesConfigFactory.eINSTANCE.createMapEntriesType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__MAP_ENTRY,
-				 FacesConfigFactory.eINSTANCE.createMapEntryType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__MESSAGE_BUNDLE,
-				 FacesConfigFactory.eINSTANCE.createMessageBundleType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__NAME,
-				 FacesConfigFactory.eINSTANCE.createNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__NAVIGATION_CASE,
-				 FacesConfigFactory.eINSTANCE.createNavigationCaseType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__NAVIGATION_HANDLER,
-				 FacesConfigFactory.eINSTANCE.createNavigationHandlerType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__NAVIGATION_RULE,
-				 FacesConfigFactory.eINSTANCE.createNavigationRuleType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__NULL_VALUE,
-				 FacesConfigFactory.eINSTANCE.createNullValueType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__ORDERING,
-				 FacesConfigFactory.eINSTANCE.createOrderingType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__ORDERING_ORDERING,
-				 FacesConfigFactory.eINSTANCE.createOrderingOrderingType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__OTHERS,
-				 FacesConfigFactory.eINSTANCE.createOrderingOthersType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__PARTIAL_VIEW_CONTEXT_FACTORY,
-				 FacesConfigFactory.eINSTANCE.createPartialViewContextFactoryType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__PHASE_LISTENER,
-				 FacesConfigFactory.eINSTANCE.createPhaseListenerType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY,
-				 FacesConfigFactory.eINSTANCE.createPropertyType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY_CLASS,
-				 FacesConfigFactory.eINSTANCE.createPropertyClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY_EXTENSION,
-				 FacesConfigFactory.eINSTANCE.createPropertyExtensionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY_NAME,
-				 FacesConfigFactory.eINSTANCE.createPropertyNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY_RESOLVER,
-				 FacesConfigFactory.eINSTANCE.createPropertyResolverType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__REDIRECT,
-				 FacesConfigFactory.eINSTANCE.createRedirectType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__REDIRECT_VIEW_PARAM,
-				 FacesConfigFactory.eINSTANCE.createRedirectViewParamType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__REFERENCED_BEAN,
-				 FacesConfigFactory.eINSTANCE.createReferencedBeanType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__REFERENCED_BEAN_CLASS,
-				 FacesConfigFactory.eINSTANCE.createReferencedBeanClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__REFERENCED_BEAN_NAME,
-				 FacesConfigFactory.eINSTANCE.createReferencedBeanNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDERER,
-				 FacesConfigFactory.eINSTANCE.createRendererType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDERER_CLASS,
-				 FacesConfigFactory.eINSTANCE.createRendererClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDERER_EXTENSION,
-				 FacesConfigFactory.eINSTANCE.createRendererExtensionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDERER_TYPE,
-				 FacesConfigFactory.eINSTANCE.createRendererTypeType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDER_KIT,
-				 FacesConfigFactory.eINSTANCE.createRenderKitType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDER_KIT_CLASS,
-				 FacesConfigFactory.eINSTANCE.createRenderKitClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDER_KIT_FACTORY,
-				 FacesConfigFactory.eINSTANCE.createRenderKitFactoryType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDER_KIT_ID,
-				 FacesConfigFactory.eINSTANCE.createRenderKitIdType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__RESOURCE_HANDLER,
-				 FacesConfigFactory.eINSTANCE.createResourceHandlerType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__SMALL_ICON,
-				 FacesConfigFactory.eINSTANCE.createSmallIconType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__SOURCE_CLASS,
-				 FacesConfigFactory.eINSTANCE.createSourceClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__STATE_MANAGER,
-				 FacesConfigFactory.eINSTANCE.createStateManagerType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__SUGGESTED_VALUE,
-				 FacesConfigFactory.eINSTANCE.createSuggestedValueType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__SUPPORTED_LOCALE,
-				 FacesConfigFactory.eINSTANCE.createSupportedLocaleType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__SYSTEM_EVENT_CLASS,
-				 FacesConfigFactory.eINSTANCE.createSystemEventClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER,
-				 FacesConfigFactory.eINSTANCE.createSystemEventListenerType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER_CLASS,
-				 FacesConfigFactory.eINSTANCE.createSystemEventListenerClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__TAG_HANDLER_DELEGATE_FACTORY,
-				 FacesConfigFactory.eINSTANCE.createTagHandlerDelegateFactoryType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__TO_VIEW_ID,
-				 FacesConfigFactory.eINSTANCE.createToViewIdType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALIDATOR,
-				 FacesConfigFactory.eINSTANCE.createValidatorType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALIDATOR_CLASS,
-				 FacesConfigFactory.eINSTANCE.createValidatorClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALIDATOR_ID,
-				 FacesConfigFactory.eINSTANCE.createValidatorIdType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALUE,
-				 FacesConfigFactory.eINSTANCE.createValueType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALUE_CLASS,
-				 FacesConfigFactory.eINSTANCE.createValueClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__VARIABLE_RESOLVER,
-				 FacesConfigFactory.eINSTANCE.createVariableResolverType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__VIEW_DECLARATION_LANGUAGE_FACTORY,
-				 FacesConfigFactory.eINSTANCE.createViewDeclarationLanguageFactoryType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__VIEW_HANDLER,
-				 FacesConfigFactory.eINSTANCE.createViewHandlerType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DOCUMENT_ROOT__VISIT_CONTEXT_FACTORY,
-				 FacesConfigFactory.eINSTANCE.createVisitContextFactoryType()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DynamicAttributeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DynamicAttributeItemProvider.java
deleted file mode 100644
index e44c452..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DynamicAttributeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.DynamicAttribute;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.DynamicAttribute} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class DynamicAttributeItemProvider
-    extends ItemProviderAdapter
-    implements	
-        IEditingDomainItemProvider,	
-        IStructuredItemContentProvider,	
-        ITreeItemContentProvider,	
-        IItemLabelProvider,	
-        IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public DynamicAttributeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public List 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 -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addNamePropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_DynamicAttribute_name_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_DynamicAttribute_name_feature", "_UI_DynamicAttribute_type"),
-				 FacesConfigPackage.Literals.DYNAMIC_ATTRIBUTE__NAME,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Value feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addValuePropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_DynamicAttribute_value_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_DynamicAttribute_value_feature", "_UI_DynamicAttribute_type"),
-				 FacesConfigPackage.Literals.DYNAMIC_ATTRIBUTE__VALUE,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns DynamicAttribute.gif.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/DynamicAttribute"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getText(Object object) {
-		String label = ((DynamicAttribute)object).getName();
-		return label == null || label.length() == 0 ?
-			getString("_UI_DynamicAttribute_type") :
-			getString("_UI_DynamicAttribute_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-    public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(DynamicAttribute.class)) {
-			case FacesConfigPackage.DYNAMIC_ATTRIBUTE__NAME:
-			case FacesConfigPackage.DYNAMIC_ATTRIBUTE__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
-	 */
-    protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DynamicElementItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DynamicElementItemProvider.java
deleted file mode 100644
index cd537af..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/DynamicElementItemProvider.java
+++ /dev/null
@@ -1,254 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.DynamicElement;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.DynamicElement} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class DynamicElementItemProvider
-    extends ItemProviderAdapter
-    implements	
-        IEditingDomainItemProvider,	
-        IStructuredItemContentProvider,	
-        ITreeItemContentProvider,	
-        IItemLabelProvider,	
-        IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public DynamicElementItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addNamePropertyDescriptor(object);
-			addAttributesPropertyDescriptor(object);
-			addTextContentPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Attributes feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addAttributesPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_DynamicElement_attributes_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_DynamicElement_attributes_feature", "_UI_DynamicElement_type"),
-				 FacesConfigPackage.Literals.DYNAMIC_ELEMENT__ATTRIBUTES,
-				 true,
-				 false,
-				 true,
-				 null,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_DynamicElement_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_DynamicElement_textContent_feature", "_UI_DynamicElement_type"),
-				 FacesConfigPackage.Literals.DYNAMIC_ELEMENT__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Name feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addNamePropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_DynamicElement_name_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_DynamicElement_name_feature", "_UI_DynamicElement_type"),
-				 FacesConfigPackage.Literals.DYNAMIC_ELEMENT__NAME,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * 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
-	 */
-    public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.DYNAMIC_ELEMENT__CHILD_NODES);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 DynamicElement.gif.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/DynamicElement"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getText(Object object) {
-		String label = ((DynamicElement)object).getName();
-		return label == null || label.length() == 0 ?
-			getString("_UI_DynamicElement_type") :
-			getString("_UI_DynamicElement_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-    public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(DynamicElement.class)) {
-			case FacesConfigPackage.DYNAMIC_ELEMENT__NAME:
-			case FacesConfigPackage.DYNAMIC_ELEMENT__TEXT_CONTENT:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.DYNAMIC_ELEMENT__CHILD_NODES:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-    protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.DYNAMIC_ELEMENT__CHILD_NODES,
-				 FacesConfigFactory.eINSTANCE.createDynamicElement()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ELResolverTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ELResolverTypeItemProvider.java
deleted file mode 100644
index cb209a1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ELResolverTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.ELResolverType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ELResolverType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ELResolverTypeItemProvider
-    extends ItemProviderAdapter
-    implements	
-        IEditingDomainItemProvider,	
-        IStructuredItemContentProvider,	
-        ITreeItemContentProvider,	
-        IItemLabelProvider,	
-        IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ELResolverTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ELResolverType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ELResolverType_textContent_feature", "_UI_ELResolverType_type"),
-				 FacesConfigPackage.Literals.EL_RESOLVER_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ELResolverType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ELResolverType_id_feature", "_UI_ELResolverType_type"),
-				 FacesConfigPackage.Literals.EL_RESOLVER_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns ELResolverType.gif.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ELResolverType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getText(Object object) {
-		String label = ((ELResolverType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ELResolverType_type") :
-			getString("_UI_ELResolverType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-    public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ELResolverType.class)) {
-			case FacesConfigPackage.EL_RESOLVER_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.EL_RESOLVER_TYPE__ID:
-				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
-	 */
-    protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ExceptionHandlerFactoryTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ExceptionHandlerFactoryTypeItemProvider.java
deleted file mode 100644
index 654f40f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ExceptionHandlerFactoryTypeItemProvider.java
+++ /dev/null
@@ -1,216 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.ExceptionHandlerFactoryType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ExceptionHandlerFactoryType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ExceptionHandlerFactoryTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource,
-		ITableItemLabelProvider{
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ExceptionHandlerFactoryTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ExceptionHandlerFactoryType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ExceptionHandlerFactoryType_textContent_feature", "_UI_ExceptionHandlerFactoryType_type"),
-				 FacesConfigPackage.Literals.EXCEPTION_HANDLER_FACTORY_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ExceptionHandlerFactoryType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ExceptionHandlerFactoryType_id_feature", "_UI_ExceptionHandlerFactoryType_type"),
-				 FacesConfigPackage.Literals.EXCEPTION_HANDLER_FACTORY_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This returns ExceptionHandlerFactoryType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ExceptionHandlerFactoryType"));
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((ExceptionHandlerFactoryType) object).getTextContent();
-		return label == null || label.length() == 0 ? getString("_UI_ExceptionHandlerFactoryType_type")
-				: label;
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ExceptionHandlerFactoryType.class)) {
-			case FacesConfigPackage.EXCEPTION_HANDLER_FACTORY_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.EXCEPTION_HANDLER_FACTORY_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		// TODO Auto-generated method stub
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_ExceptionHandlerFactoryType_type"); //$NON-NLS-1$
-		}
-		return null;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ExtensionTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ExtensionTypeItemProvider.java
deleted file mode 100644
index 66bcdb8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ExtensionTypeItemProvider.java
+++ /dev/null
@@ -1,206 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.ExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ExtensionType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ExtensionTypeItemProvider
-    extends ItemProviderAdapter
-    implements	
-        IEditingDomainItemProvider,	
-        IStructuredItemContentProvider,	
-        ITreeItemContentProvider,	
-        IItemLabelProvider,	
-        IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ExtensionTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addChildNodesPropertyDescriptor(object);
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Child Nodes feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addChildNodesPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ExtensionType_childNodes_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ExtensionType_childNodes_feature", "_UI_ExtensionType_type"),
-				 FacesConfigPackage.Literals.EXTENSION_TYPE__CHILD_NODES,
-				 true,
-				 false,
-				 true,
-				 null,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ExtensionType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ExtensionType_textContent_feature", "_UI_ExtensionType_type"),
-				 FacesConfigPackage.Literals.EXTENSION_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ExtensionType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ExtensionType_id_feature", "_UI_ExtensionType_type"),
-				 FacesConfigPackage.Literals.EXTENSION_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getText(Object object) {
-		String label = ((ExtensionType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ExtensionType_type") :
-			getString("_UI_ExtensionType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-    public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ExtensionType.class)) {
-			case FacesConfigPackage.EXTENSION_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.EXTENSION_TYPE__ID:
-				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
-	 */
-    protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ExternalContextFactoryTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ExternalContextFactoryTypeItemProvider.java
deleted file mode 100644
index 6e2d0e3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ExternalContextFactoryTypeItemProvider.java
+++ /dev/null
@@ -1,218 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.ExternalContextFactoryType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ExternalContextFactoryType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ExternalContextFactoryTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource,
-		ITableItemLabelProvider{
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ExternalContextFactoryTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc --> 
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ExternalContextFactoryType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ExternalContextFactoryType_textContent_feature", "_UI_ExternalContextFactoryType_type"),
-				 FacesConfigPackage.Literals.EXTERNAL_CONTEXT_FACTORY_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc --> 
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ExternalContextFactoryType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ExternalContextFactoryType_id_feature", "_UI_ExternalContextFactoryType_type"),
-				 FacesConfigPackage.Literals.EXTERNAL_CONTEXT_FACTORY_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This returns ExternalContextFactoryType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ExternalContextFactoryType"));
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((ExternalContextFactoryType) object).getTextContent();
-		return label == null || label.length() == 0 ? getString("_UI_ExternalContextFactoryType_type")
-				: label;
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ExternalContextFactoryType.class)) {
-			case FacesConfigPackage.EXTERNAL_CONTEXT_FACTORY_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.EXTERNAL_CONTEXT_FACTORY_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		// TODO Auto-generated method stub
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_ExternalContextFactoryType_type"); //$NON-NLS-1$
-		}
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacesConfigEditPlugin.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacesConfigEditPlugin.java
deleted file mode 100644
index 05c525e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacesConfigEditPlugin.java
+++ /dev/null
@@ -1,103 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.provider;
-
-import org.eclipse.emf.common.EMFPlugin;
-import org.eclipse.emf.common.util.ResourceLocator;
-
-/**
- * This is the central singleton for the FacesConfig edit plugin.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public final class FacesConfigEditPlugin extends EMFPlugin {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Keep track of the singleton.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final FacesConfigEditPlugin INSTANCE = new FacesConfigEditPlugin();
-
-	/**
-	 * 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 FacesConfigEditPlugin() {
-		super
-		  (new ResourceLocator [] {
-		   });
-	}
-
-	/**
-	 * Returns the singleton instance of the Eclipse plugin.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the singleton instance.
-	 * @generated
-	 */
-	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;
-		}
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacesConfigExtensionTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacesConfigExtensionTypeItemProvider.java
deleted file mode 100644
index 1767f9f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacesConfigExtensionTypeItemProvider.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.edit.provider.IEditingDomainItemProvider;
-import org.eclipse.emf.edit.provider.IItemLabelProvider;
-import org.eclipse.emf.edit.provider.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigExtensionType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigExtensionType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public class FacesConfigExtensionTypeItemProvider
-    extends ExtensionTypeItemProvider
-    implements	
-        IEditingDomainItemProvider,	
-        IStructuredItemContentProvider,	
-        ITreeItemContentProvider,	
-        IItemLabelProvider,	
-        IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    @SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public FacesConfigExtensionTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This returns FacesConfigExtensionType.gif.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-    public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/FacesConfigExtensionType")); //$NON-NLS-1$
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-    public String getText(Object object) {
-		String label = ((FacesConfigExtensionType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_FacesConfigExtensionType_type") : //$NON-NLS-1$
-			getString("_UI_FacesConfigExtensionType_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
-	 */
-    public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-		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
-	 */
-    protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacesConfigItemProviderAdapterFactory.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacesConfigItemProviderAdapterFactory.java
deleted file mode 100644
index b196519..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacesConfigItemProviderAdapterFactory.java
+++ /dev/null
@@ -1,2995 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ITableItemLabelProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.jst.jsf.facesconfig.emf.util.FacesConfigAdapterFactory;
-
-/**
- * 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 FacesConfigItemProviderAdapterFactory extends FacesConfigAdapterFactory implements ComposeableAdapterFactory, IChangeNotifier, IDisposable {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * 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 supportedTypes = new ArrayList();
-
-    /**
-     * This constructs an instance.
-     * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-     * @generated NOT
-     */
-	public FacesConfigItemProviderAdapterFactory() {
-        supportedTypes.add(IEditingDomainItemProvider.class);
-        supportedTypes.add(IStructuredItemContentProvider.class);
-        supportedTypes.add(ITreeItemContentProvider.class);
-        supportedTypes.add(IItemLabelProvider.class);
-        supportedTypes.add(IItemPropertySource.class);		
-        supportedTypes.add(ITableItemLabelProvider.class);
-    }
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.AbsoluteOrderingType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected AbsoluteOrderingTypeItemProvider absoluteOrderingTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.AbsoluteOrderingType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createAbsoluteOrderingTypeAdapter() {
-		if (absoluteOrderingTypeItemProvider == null) {
-			absoluteOrderingTypeItemProvider = new AbsoluteOrderingTypeItemProvider(this);
-		}
-
-		return absoluteOrderingTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ActionListenerType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ActionListenerTypeItemProvider actionListenerTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ActionListenerType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createActionListenerTypeAdapter() {
-		if (actionListenerTypeItemProvider == null) {
-			actionListenerTypeItemProvider = new ActionListenerTypeItemProvider(this);
-		}
-
-		return actionListenerTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationFactoryType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ApplicationFactoryTypeItemProvider applicationFactoryTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationFactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createApplicationFactoryTypeAdapter() {
-		if (applicationFactoryTypeItemProvider == null) {
-			applicationFactoryTypeItemProvider = new ApplicationFactoryTypeItemProvider(this);
-		}
-
-		return applicationFactoryTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ApplicationTypeItemProvider applicationTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createApplicationTypeAdapter() {
-		if (applicationTypeItemProvider == null) {
-			applicationTypeItemProvider = new ApplicationTypeItemProvider(this);
-		}
-
-		return applicationTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.AttributeClassType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected AttributeClassTypeItemProvider attributeClassTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.AttributeClassType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createAttributeClassTypeAdapter() {
-		if (attributeClassTypeItemProvider == null) {
-			attributeClassTypeItemProvider = new AttributeClassTypeItemProvider(this);
-		}
-
-		return attributeClassTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.AttributeExtensionType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected AttributeExtensionTypeItemProvider attributeExtensionTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.AttributeExtensionType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createAttributeExtensionTypeAdapter() {
-		if (attributeExtensionTypeItemProvider == null) {
-			attributeExtensionTypeItemProvider = new AttributeExtensionTypeItemProvider(this);
-		}
-
-		return attributeExtensionTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.AttributeNameType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected AttributeNameTypeItemProvider attributeNameTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.AttributeNameType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createAttributeNameTypeAdapter() {
-		if (attributeNameTypeItemProvider == null) {
-			attributeNameTypeItemProvider = new AttributeNameTypeItemProvider(this);
-		}
-
-		return attributeNameTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected AttributeTypeItemProvider attributeTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createAttributeTypeAdapter() {
-		if (attributeTypeItemProvider == null) {
-			attributeTypeItemProvider = new AttributeTypeItemProvider(this);
-		}
-
-		return attributeTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorClassType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected BehaviorClassTypeItemProvider behaviorClassTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorClassType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createBehaviorClassTypeAdapter() {
-		if (behaviorClassTypeItemProvider == null) {
-			behaviorClassTypeItemProvider = new BehaviorClassTypeItemProvider(this);
-		}
-
-		return behaviorClassTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorIdType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected BehaviorIdTypeItemProvider behaviorIdTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorIdType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createBehaviorIdTypeAdapter() {
-		if (behaviorIdTypeItemProvider == null) {
-			behaviorIdTypeItemProvider = new BehaviorIdTypeItemProvider(this);
-		}
-
-		return behaviorIdTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected BehaviorTypeItemProvider behaviorTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createBehaviorTypeAdapter() {
-		if (behaviorTypeItemProvider == null) {
-			behaviorTypeItemProvider = new BehaviorTypeItemProvider(this);
-		}
-
-		return behaviorTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorExtensionType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected BehaviorExtensionTypeItemProvider behaviorExtensionTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorExtensionType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createBehaviorExtensionTypeAdapter() {
-		if (behaviorExtensionTypeItemProvider == null) {
-			behaviorExtensionTypeItemProvider = new BehaviorExtensionTypeItemProvider(this);
-		}
-
-		return behaviorExtensionTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererClassType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ClientBehaviorRendererClassTypeItemProvider clientBehaviorRendererClassTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererClassType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createClientBehaviorRendererClassTypeAdapter() {
-		if (clientBehaviorRendererClassTypeItemProvider == null) {
-			clientBehaviorRendererClassTypeItemProvider = new ClientBehaviorRendererClassTypeItemProvider(this);
-		}
-
-		return clientBehaviorRendererClassTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ClientBehaviorRendererTypeItemProvider clientBehaviorRendererTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createClientBehaviorRendererTypeAdapter() {
-		if (clientBehaviorRendererTypeItemProvider == null) {
-			clientBehaviorRendererTypeItemProvider = new ClientBehaviorRendererTypeItemProvider(this);
-		}
-
-		return clientBehaviorRendererTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererTypeType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ClientBehaviorRendererTypeTypeItemProvider clientBehaviorRendererTypeTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererTypeType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createClientBehaviorRendererTypeTypeAdapter() {
-		if (clientBehaviorRendererTypeTypeItemProvider == null) {
-			clientBehaviorRendererTypeTypeItemProvider = new ClientBehaviorRendererTypeTypeItemProvider(this);
-		}
-
-		return clientBehaviorRendererTypeTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ComponentClassType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ComponentClassTypeItemProvider componentClassTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ComponentClassType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createComponentClassTypeAdapter() {
-		if (componentClassTypeItemProvider == null) {
-			componentClassTypeItemProvider = new ComponentClassTypeItemProvider(this);
-		}
-
-		return componentClassTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ComponentExtensionType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ComponentExtensionTypeItemProvider componentExtensionTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ComponentExtensionType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createComponentExtensionTypeAdapter() {
-		if (componentExtensionTypeItemProvider == null) {
-			componentExtensionTypeItemProvider = new ComponentExtensionTypeItemProvider(this);
-		}
-
-		return componentExtensionTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ComponentFamilyType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ComponentFamilyTypeItemProvider componentFamilyTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ComponentFamilyType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createComponentFamilyTypeAdapter() {
-		if (componentFamilyTypeItemProvider == null) {
-			componentFamilyTypeItemProvider = new ComponentFamilyTypeItemProvider(this);
-		}
-
-		return componentFamilyTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ComponentTypeItemProvider componentTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createComponentTypeAdapter() {
-		if (componentTypeItemProvider == null) {
-			componentTypeItemProvider = new ComponentTypeItemProvider(this);
-		}
-
-		return componentTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ComponentTypeType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ComponentTypeTypeItemProvider componentTypeTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ComponentTypeType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createComponentTypeTypeAdapter() {
-		if (componentTypeTypeItemProvider == null) {
-			componentTypeTypeItemProvider = new ComponentTypeTypeItemProvider(this);
-		}
-
-		return componentTypeTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ConverterClassType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ConverterClassTypeItemProvider converterClassTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ConverterClassType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createConverterClassTypeAdapter() {
-		if (converterClassTypeItemProvider == null) {
-			converterClassTypeItemProvider = new ConverterClassTypeItemProvider(this);
-		}
-
-		return converterClassTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ConverterForClassType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ConverterForClassTypeItemProvider converterForClassTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ConverterForClassType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createConverterForClassTypeAdapter() {
-		if (converterForClassTypeItemProvider == null) {
-			converterForClassTypeItemProvider = new ConverterForClassTypeItemProvider(this);
-		}
-
-		return converterForClassTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ConverterIdType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ConverterIdTypeItemProvider converterIdTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ConverterIdType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createConverterIdTypeAdapter() {
-		if (converterIdTypeItemProvider == null) {
-			converterIdTypeItemProvider = new ConverterIdTypeItemProvider(this);
-		}
-
-		return converterIdTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ConverterTypeItemProvider converterTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createConverterTypeAdapter() {
-		if (converterTypeItemProvider == null) {
-			converterTypeItemProvider = new ConverterTypeItemProvider(this);
-		}
-
-		return converterTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.DefaultLocaleType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected DefaultLocaleTypeItemProvider defaultLocaleTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.DefaultLocaleType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createDefaultLocaleTypeAdapter() {
-		if (defaultLocaleTypeItemProvider == null) {
-			defaultLocaleTypeItemProvider = new DefaultLocaleTypeItemProvider(this);
-		}
-
-		return defaultLocaleTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.DefaultRenderKitIdType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected DefaultRenderKitIdTypeItemProvider defaultRenderKitIdTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.DefaultRenderKitIdType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createDefaultRenderKitIdTypeAdapter() {
-		if (defaultRenderKitIdTypeItemProvider == null) {
-			defaultRenderKitIdTypeItemProvider = new DefaultRenderKitIdTypeItemProvider(this);
-		}
-
-		return defaultRenderKitIdTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValidatorsType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected DefaultValidatorsTypeItemProvider defaultValidatorsTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValidatorsType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createDefaultValidatorsTypeAdapter() {
-		if (defaultValidatorsTypeItemProvider == null) {
-			defaultValidatorsTypeItemProvider = new DefaultValidatorsTypeItemProvider(this);
-		}
-
-		return defaultValidatorsTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValueType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected DefaultValueTypeItemProvider defaultValueTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValueType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createDefaultValueTypeAdapter() {
-		if (defaultValueTypeItemProvider == null) {
-			defaultValueTypeItemProvider = new DefaultValueTypeItemProvider(this);
-		}
-
-		return defaultValueTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected DescriptionTypeItemProvider descriptionTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createDescriptionTypeAdapter() {
-		if (descriptionTypeItemProvider == null) {
-			descriptionTypeItemProvider = new DescriptionTypeItemProvider(this);
-		}
-
-		return descriptionTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected DisplayNameTypeItemProvider displayNameTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createDisplayNameTypeAdapter() {
-		if (displayNameTypeItemProvider == null) {
-			displayNameTypeItemProvider = new DisplayNameTypeItemProvider(this);
-		}
-
-		return displayNameTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected DocumentRootItemProvider documentRootItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createDocumentRootAdapter() {
-		if (documentRootItemProvider == null) {
-			documentRootItemProvider = new DocumentRootItemProvider(this);
-		}
-
-		return documentRootItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.DynamicAttribute} instances.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected DynamicAttributeItemProvider dynamicAttributeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.DynamicAttribute}.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Adapter createDynamicAttributeAdapter() {
-		if (dynamicAttributeItemProvider == null) {
-			dynamicAttributeItemProvider = new DynamicAttributeItemProvider(this);
-		}
-
-		return dynamicAttributeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.DynamicElement} instances.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected DynamicElementItemProvider dynamicElementItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.DynamicElement}.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Adapter createDynamicElementAdapter() {
-		if (dynamicElementItemProvider == null) {
-			dynamicElementItemProvider = new DynamicElementItemProvider(this);
-		}
-
-		return dynamicElementItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ELResolverType} instances.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected ELResolverTypeItemProvider elResolverTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ELResolverType}.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Adapter createELResolverTypeAdapter() {
-		if (elResolverTypeItemProvider == null) {
-			elResolverTypeItemProvider = new ELResolverTypeItemProvider(this);
-		}
-
-		return elResolverTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ExceptionHandlerFactoryType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ExceptionHandlerFactoryTypeItemProvider exceptionHandlerFactoryTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ExceptionHandlerFactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createExceptionHandlerFactoryTypeAdapter() {
-		if (exceptionHandlerFactoryTypeItemProvider == null) {
-			exceptionHandlerFactoryTypeItemProvider = new ExceptionHandlerFactoryTypeItemProvider(this);
-		}
-
-		return exceptionHandlerFactoryTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ExternalContextFactoryType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ExternalContextFactoryTypeItemProvider externalContextFactoryTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ExternalContextFactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createExternalContextFactoryTypeAdapter() {
-		if (externalContextFactoryTypeItemProvider == null) {
-			externalContextFactoryTypeItemProvider = new ExternalContextFactoryTypeItemProvider(this);
-		}
-
-		return externalContextFactoryTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigExtensionType} instances.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected FacesConfigExtensionTypeItemProvider facesConfigExtensionTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigExtensionType}.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Adapter createFacesConfigExtensionTypeAdapter() {
-		if (facesConfigExtensionTypeItemProvider == null) {
-			facesConfigExtensionTypeItemProvider = new FacesConfigExtensionTypeItemProvider(this);
-		}
-
-		return facesConfigExtensionTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.FactoryExtensionType} instances.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected FactoryExtensionTypeItemProvider factoryExtensionTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FactoryExtensionType}.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Adapter createFactoryExtensionTypeAdapter() {
-		if (factoryExtensionTypeItemProvider == null) {
-			factoryExtensionTypeItemProvider = new FactoryExtensionTypeItemProvider(this);
-		}
-
-		return factoryExtensionTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleExtensionType} instances.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected LifecycleExtensionTypeItemProvider lifecycleExtensionTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleExtensionType}.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Adapter createLifecycleExtensionTypeAdapter() {
-		if (lifecycleExtensionTypeItemProvider == null) {
-			lifecycleExtensionTypeItemProvider = new LifecycleExtensionTypeItemProvider(this);
-		}
-
-		return lifecycleExtensionTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanExtensionType} instances.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected ManagedBeanExtensionTypeItemProvider managedBeanExtensionTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanExtensionType}.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Adapter createManagedBeanExtensionTypeAdapter() {
-		if (managedBeanExtensionTypeItemProvider == null) {
-			managedBeanExtensionTypeItemProvider = new ManagedBeanExtensionTypeItemProvider(this);
-		}
-
-		return managedBeanExtensionTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleExtensionType} instances.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected NavigationRuleExtensionTypeItemProvider navigationRuleExtensionTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleExtensionType}.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Adapter createNavigationRuleExtensionTypeAdapter() {
-		if (navigationRuleExtensionTypeItemProvider == null) {
-			navigationRuleExtensionTypeItemProvider = new NavigationRuleExtensionTypeItemProvider(this);
-		}
-
-		return navigationRuleExtensionTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorExtensionType} instances.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected ValidatorExtensionTypeItemProvider validatorExtensionTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorExtensionType}.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Adapter createValidatorExtensionTypeAdapter() {
-		if (validatorExtensionTypeItemProvider == null) {
-			validatorExtensionTypeItemProvider = new ValidatorExtensionTypeItemProvider(this);
-		}
-
-		return validatorExtensionTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected FacesConfigTypeItemProvider facesConfigTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createFacesConfigTypeAdapter() {
-		if (facesConfigTypeItemProvider == null) {
-			facesConfigTypeItemProvider = new FacesConfigTypeItemProvider(this);
-		}
-
-		return facesConfigTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.FacesContextFactoryType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected FacesContextFactoryTypeItemProvider facesContextFactoryTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FacesContextFactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createFacesContextFactoryTypeAdapter() {
-		if (facesContextFactoryTypeItemProvider == null) {
-			facesContextFactoryTypeItemProvider = new FacesContextFactoryTypeItemProvider(this);
-		}
-
-		return facesContextFactoryTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.FacetExtensionType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected FacetExtensionTypeItemProvider facetExtensionTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FacetExtensionType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createFacetExtensionTypeAdapter() {
-		if (facetExtensionTypeItemProvider == null) {
-			facetExtensionTypeItemProvider = new FacetExtensionTypeItemProvider(this);
-		}
-
-		return facetExtensionTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.FacetNameType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected FacetNameTypeItemProvider facetNameTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FacetNameType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createFacetNameTypeAdapter() {
-		if (facetNameTypeItemProvider == null) {
-			facetNameTypeItemProvider = new FacetNameTypeItemProvider(this);
-		}
-
-		return facetNameTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.FacetType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected FacetTypeItemProvider facetTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FacetType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createFacetTypeAdapter() {
-		if (facetTypeItemProvider == null) {
-			facetTypeItemProvider = new FacetTypeItemProvider(this);
-		}
-
-		return facetTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected FactoryTypeItemProvider factoryTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createFactoryTypeAdapter() {
-		if (factoryTypeItemProvider == null) {
-			factoryTypeItemProvider = new FactoryTypeItemProvider(this);
-		}
-
-		return factoryTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.FromActionType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected FromActionTypeItemProvider fromActionTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FromActionType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createFromActionTypeAdapter() {
-		if (fromActionTypeItemProvider == null) {
-			fromActionTypeItemProvider = new FromActionTypeItemProvider(this);
-		}
-
-		return fromActionTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.FromOutcomeType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected FromOutcomeTypeItemProvider fromOutcomeTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FromOutcomeType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createFromOutcomeTypeAdapter() {
-		if (fromOutcomeTypeItemProvider == null) {
-			fromOutcomeTypeItemProvider = new FromOutcomeTypeItemProvider(this);
-		}
-
-		return fromOutcomeTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.FromViewIdType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected FromViewIdTypeItemProvider fromViewIdTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FromViewIdType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createFromViewIdTypeAdapter() {
-		if (fromViewIdTypeItemProvider == null) {
-			fromViewIdTypeItemProvider = new FromViewIdTypeItemProvider(this);
-		}
-
-		return fromViewIdTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.IconType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected IconTypeItemProvider iconTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.IconType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createIconTypeAdapter() {
-		if (iconTypeItemProvider == null) {
-			iconTypeItemProvider = new IconTypeItemProvider(this);
-		}
-
-		return iconTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.IfType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected IfTypeItemProvider ifTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.IfType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createIfTypeAdapter() {
-		if (ifTypeItemProvider == null) {
-			ifTypeItemProvider = new IfTypeItemProvider(this);
-		}
-
-		return ifTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.KeyClassType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected KeyClassTypeItemProvider keyClassTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.KeyClassType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createKeyClassTypeAdapter() {
-		if (keyClassTypeItemProvider == null) {
-			keyClassTypeItemProvider = new KeyClassTypeItemProvider(this);
-		}
-
-		return keyClassTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.KeyType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected KeyTypeItemProvider keyTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.KeyType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createKeyTypeAdapter() {
-		if (keyTypeItemProvider == null) {
-			keyTypeItemProvider = new KeyTypeItemProvider(this);
-		}
-
-		return keyTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.LargeIconType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected LargeIconTypeItemProvider largeIconTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.LargeIconType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createLargeIconTypeAdapter() {
-		if (largeIconTypeItemProvider == null) {
-			largeIconTypeItemProvider = new LargeIconTypeItemProvider(this);
-		}
-
-		return largeIconTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleFactoryType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected LifecycleFactoryTypeItemProvider lifecycleFactoryTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleFactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createLifecycleFactoryTypeAdapter() {
-		if (lifecycleFactoryTypeItemProvider == null) {
-			lifecycleFactoryTypeItemProvider = new LifecycleFactoryTypeItemProvider(this);
-		}
-
-		return lifecycleFactoryTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected LifecycleTypeItemProvider lifecycleTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createLifecycleTypeAdapter() {
-		if (lifecycleTypeItemProvider == null) {
-			lifecycleTypeItemProvider = new LifecycleTypeItemProvider(this);
-		}
-
-		return lifecycleTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ListEntriesTypeItemProvider listEntriesTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createListEntriesTypeAdapter() {
-		if (listEntriesTypeItemProvider == null) {
-			listEntriesTypeItemProvider = new ListEntriesTypeItemProvider(this);
-		}
-
-		return listEntriesTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected LocaleConfigTypeItemProvider localeConfigTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createLocaleConfigTypeAdapter() {
-		if (localeConfigTypeItemProvider == null) {
-			localeConfigTypeItemProvider = new LocaleConfigTypeItemProvider(this);
-		}
-
-		return localeConfigTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanClassType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ManagedBeanClassTypeItemProvider managedBeanClassTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanClassType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createManagedBeanClassTypeAdapter() {
-		if (managedBeanClassTypeItemProvider == null) {
-			managedBeanClassTypeItemProvider = new ManagedBeanClassTypeItemProvider(this);
-		}
-
-		return managedBeanClassTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanNameType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ManagedBeanNameTypeItemProvider managedBeanNameTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanNameType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createManagedBeanNameTypeAdapter() {
-		if (managedBeanNameTypeItemProvider == null) {
-			managedBeanNameTypeItemProvider = new ManagedBeanNameTypeItemProvider(this);
-		}
-
-		return managedBeanNameTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanScopeType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ManagedBeanScopeTypeItemProvider managedBeanScopeTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanScopeType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createManagedBeanScopeTypeAdapter() {
-		if (managedBeanScopeTypeItemProvider == null) {
-			managedBeanScopeTypeItemProvider = new ManagedBeanScopeTypeItemProvider(this);
-		}
-
-		return managedBeanScopeTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ManagedBeanTypeItemProvider managedBeanTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createManagedBeanTypeAdapter() {
-		if (managedBeanTypeItemProvider == null) {
-			managedBeanTypeItemProvider = new ManagedBeanTypeItemProvider(this);
-		}
-
-		return managedBeanTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ManagedPropertyTypeItemProvider managedPropertyTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createManagedPropertyTypeAdapter() {
-		if (managedPropertyTypeItemProvider == null) {
-			managedPropertyTypeItemProvider = new ManagedPropertyTypeItemProvider(this);
-		}
-
-		return managedPropertyTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected MapEntriesTypeItemProvider mapEntriesTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createMapEntriesTypeAdapter() {
-		if (mapEntriesTypeItemProvider == null) {
-			mapEntriesTypeItemProvider = new MapEntriesTypeItemProvider(this);
-		}
-
-		return mapEntriesTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.MapEntryType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected MapEntryTypeItemProvider mapEntryTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.MapEntryType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createMapEntryTypeAdapter() {
-		if (mapEntryTypeItemProvider == null) {
-			mapEntryTypeItemProvider = new MapEntryTypeItemProvider(this);
-		}
-
-		return mapEntryTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.MessageBundleType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected MessageBundleTypeItemProvider messageBundleTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.MessageBundleType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createMessageBundleTypeAdapter() {
-		if (messageBundleTypeItemProvider == null) {
-			messageBundleTypeItemProvider = new MessageBundleTypeItemProvider(this);
-		}
-
-		return messageBundleTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.NameType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected NameTypeItemProvider nameTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.NameType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createNameTypeAdapter() {
-		if (nameTypeItemProvider == null) {
-			nameTypeItemProvider = new NameTypeItemProvider(this);
-		}
-
-		return nameTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected NavigationCaseTypeItemProvider navigationCaseTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createNavigationCaseTypeAdapter() {
-		if (navigationCaseTypeItemProvider == null) {
-			navigationCaseTypeItemProvider = new NavigationCaseTypeItemProvider(this);
-		}
-
-		return navigationCaseTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.NavigationHandlerType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected NavigationHandlerTypeItemProvider navigationHandlerTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.NavigationHandlerType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createNavigationHandlerTypeAdapter() {
-		if (navigationHandlerTypeItemProvider == null) {
-			navigationHandlerTypeItemProvider = new NavigationHandlerTypeItemProvider(this);
-		}
-
-		return navigationHandlerTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected NavigationRuleTypeItemProvider navigationRuleTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createNavigationRuleTypeAdapter() {
-		if (navigationRuleTypeItemProvider == null) {
-			navigationRuleTypeItemProvider = new NavigationRuleTypeItemProvider(this);
-		}
-
-		return navigationRuleTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.NullValueType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected NullValueTypeItemProvider nullValueTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.NullValueType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createNullValueTypeAdapter() {
-		if (nullValueTypeItemProvider == null) {
-			nullValueTypeItemProvider = new NullValueTypeItemProvider(this);
-		}
-
-		return nullValueTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.OrderingType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected OrderingTypeItemProvider orderingTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.OrderingType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createOrderingTypeAdapter() {
-		if (orderingTypeItemProvider == null) {
-			orderingTypeItemProvider = new OrderingTypeItemProvider(this);
-		}
-
-		return orderingTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.OrderingOrderingType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected OrderingOrderingTypeItemProvider orderingOrderingTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.OrderingOrderingType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createOrderingOrderingTypeAdapter() {
-		if (orderingOrderingTypeItemProvider == null) {
-			orderingOrderingTypeItemProvider = new OrderingOrderingTypeItemProvider(this);
-		}
-
-		return orderingOrderingTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.OrderingOthersType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected OrderingOthersTypeItemProvider orderingOthersTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.OrderingOthersType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createOrderingOthersTypeAdapter() {
-		if (orderingOthersTypeItemProvider == null) {
-			orderingOthersTypeItemProvider = new OrderingOthersTypeItemProvider(this);
-		}
-
-		return orderingOthersTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.PartialViewContextFactoryType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PartialViewContextFactoryTypeItemProvider partialViewContextFactoryTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.PartialViewContextFactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createPartialViewContextFactoryTypeAdapter() {
-		if (partialViewContextFactoryTypeItemProvider == null) {
-			partialViewContextFactoryTypeItemProvider = new PartialViewContextFactoryTypeItemProvider(this);
-		}
-
-		return partialViewContextFactoryTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.PhaseListenerType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PhaseListenerTypeItemProvider phaseListenerTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.PhaseListenerType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createPhaseListenerTypeAdapter() {
-		if (phaseListenerTypeItemProvider == null) {
-			phaseListenerTypeItemProvider = new PhaseListenerTypeItemProvider(this);
-		}
-
-		return phaseListenerTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.PropertyClassType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PropertyClassTypeItemProvider propertyClassTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.PropertyClassType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createPropertyClassTypeAdapter() {
-		if (propertyClassTypeItemProvider == null) {
-			propertyClassTypeItemProvider = new PropertyClassTypeItemProvider(this);
-		}
-
-		return propertyClassTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.PropertyExtensionType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PropertyExtensionTypeItemProvider propertyExtensionTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.PropertyExtensionType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createPropertyExtensionTypeAdapter() {
-		if (propertyExtensionTypeItemProvider == null) {
-			propertyExtensionTypeItemProvider = new PropertyExtensionTypeItemProvider(this);
-		}
-
-		return propertyExtensionTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.PropertyNameType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PropertyNameTypeItemProvider propertyNameTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.PropertyNameType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createPropertyNameTypeAdapter() {
-		if (propertyNameTypeItemProvider == null) {
-			propertyNameTypeItemProvider = new PropertyNameTypeItemProvider(this);
-		}
-
-		return propertyNameTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.PropertyResolverType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PropertyResolverTypeItemProvider propertyResolverTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.PropertyResolverType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createPropertyResolverTypeAdapter() {
-		if (propertyResolverTypeItemProvider == null) {
-			propertyResolverTypeItemProvider = new PropertyResolverTypeItemProvider(this);
-		}
-
-		return propertyResolverTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PropertyTypeItemProvider propertyTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createPropertyTypeAdapter() {
-		if (propertyTypeItemProvider == null) {
-			propertyTypeItemProvider = new PropertyTypeItemProvider(this);
-		}
-
-		return propertyTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.RedirectType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected RedirectTypeItemProvider redirectTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RedirectType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createRedirectTypeAdapter() {
-		if (redirectTypeItemProvider == null) {
-			redirectTypeItemProvider = new RedirectTypeItemProvider(this);
-		}
-
-		return redirectTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected RedirectViewParamTypeItemProvider redirectViewParamTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createRedirectViewParamTypeAdapter() {
-		if (redirectViewParamTypeItemProvider == null) {
-			redirectViewParamTypeItemProvider = new RedirectViewParamTypeItemProvider(this);
-		}
-
-		return redirectViewParamTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanClassType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ReferencedBeanClassTypeItemProvider referencedBeanClassTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanClassType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createReferencedBeanClassTypeAdapter() {
-		if (referencedBeanClassTypeItemProvider == null) {
-			referencedBeanClassTypeItemProvider = new ReferencedBeanClassTypeItemProvider(this);
-		}
-
-		return referencedBeanClassTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanNameType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ReferencedBeanNameTypeItemProvider referencedBeanNameTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanNameType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createReferencedBeanNameTypeAdapter() {
-		if (referencedBeanNameTypeItemProvider == null) {
-			referencedBeanNameTypeItemProvider = new ReferencedBeanNameTypeItemProvider(this);
-		}
-
-		return referencedBeanNameTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ReferencedBeanTypeItemProvider referencedBeanTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createReferencedBeanTypeAdapter() {
-		if (referencedBeanTypeItemProvider == null) {
-			referencedBeanTypeItemProvider = new ReferencedBeanTypeItemProvider(this);
-		}
-
-		return referencedBeanTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.RendererClassType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected RendererClassTypeItemProvider rendererClassTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RendererClassType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createRendererClassTypeAdapter() {
-		if (rendererClassTypeItemProvider == null) {
-			rendererClassTypeItemProvider = new RendererClassTypeItemProvider(this);
-		}
-
-		return rendererClassTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.RendererExtensionType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected RendererExtensionTypeItemProvider rendererExtensionTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RendererExtensionType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createRendererExtensionTypeAdapter() {
-		if (rendererExtensionTypeItemProvider == null) {
-			rendererExtensionTypeItemProvider = new RendererExtensionTypeItemProvider(this);
-		}
-
-		return rendererExtensionTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.RendererType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected RendererTypeItemProvider rendererTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RendererType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createRendererTypeAdapter() {
-		if (rendererTypeItemProvider == null) {
-			rendererTypeItemProvider = new RendererTypeItemProvider(this);
-		}
-
-		return rendererTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.RendererTypeType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected RendererTypeTypeItemProvider rendererTypeTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RendererTypeType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createRendererTypeTypeAdapter() {
-		if (rendererTypeTypeItemProvider == null) {
-			rendererTypeTypeItemProvider = new RendererTypeTypeItemProvider(this);
-		}
-
-		return rendererTypeTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitClassType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected RenderKitClassTypeItemProvider renderKitClassTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitClassType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createRenderKitClassTypeAdapter() {
-		if (renderKitClassTypeItemProvider == null) {
-			renderKitClassTypeItemProvider = new RenderKitClassTypeItemProvider(this);
-		}
-
-		return renderKitClassTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitFactoryType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected RenderKitFactoryTypeItemProvider renderKitFactoryTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitFactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createRenderKitFactoryTypeAdapter() {
-		if (renderKitFactoryTypeItemProvider == null) {
-			renderKitFactoryTypeItemProvider = new RenderKitFactoryTypeItemProvider(this);
-		}
-
-		return renderKitFactoryTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitIdType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected RenderKitIdTypeItemProvider renderKitIdTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitIdType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createRenderKitIdTypeAdapter() {
-		if (renderKitIdTypeItemProvider == null) {
-			renderKitIdTypeItemProvider = new RenderKitIdTypeItemProvider(this);
-		}
-
-		return renderKitIdTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected RenderKitTypeItemProvider renderKitTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createRenderKitTypeAdapter() {
-		if (renderKitTypeItemProvider == null) {
-			renderKitTypeItemProvider = new RenderKitTypeItemProvider(this);
-		}
-
-		return renderKitTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.SmallIconType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected SmallIconTypeItemProvider smallIconTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.SmallIconType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createSmallIconTypeAdapter() {
-		if (smallIconTypeItemProvider == null) {
-			smallIconTypeItemProvider = new SmallIconTypeItemProvider(this);
-		}
-
-		return smallIconTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.SourceClassType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected SourceClassTypeItemProvider sourceClassTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.SourceClassType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createSourceClassTypeAdapter() {
-		if (sourceClassTypeItemProvider == null) {
-			sourceClassTypeItemProvider = new SourceClassTypeItemProvider(this);
-		}
-
-		return sourceClassTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.StateManagerType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected StateManagerTypeItemProvider stateManagerTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.StateManagerType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createStateManagerTypeAdapter() {
-		if (stateManagerTypeItemProvider == null) {
-			stateManagerTypeItemProvider = new StateManagerTypeItemProvider(this);
-		}
-
-		return stateManagerTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.SuggestedValueType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected SuggestedValueTypeItemProvider suggestedValueTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.SuggestedValueType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createSuggestedValueTypeAdapter() {
-		if (suggestedValueTypeItemProvider == null) {
-			suggestedValueTypeItemProvider = new SuggestedValueTypeItemProvider(this);
-		}
-
-		return suggestedValueTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.SupportedLocaleType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected SupportedLocaleTypeItemProvider supportedLocaleTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.SupportedLocaleType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createSupportedLocaleTypeAdapter() {
-		if (supportedLocaleTypeItemProvider == null) {
-			supportedLocaleTypeItemProvider = new SupportedLocaleTypeItemProvider(this);
-		}
-
-		return supportedLocaleTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventClassType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected SystemEventClassTypeItemProvider systemEventClassTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventClassType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createSystemEventClassTypeAdapter() {
-		if (systemEventClassTypeItemProvider == null) {
-			systemEventClassTypeItemProvider = new SystemEventClassTypeItemProvider(this);
-		}
-
-		return systemEventClassTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerClassType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected SystemEventListenerClassTypeItemProvider systemEventListenerClassTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerClassType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createSystemEventListenerClassTypeAdapter() {
-		if (systemEventListenerClassTypeItemProvider == null) {
-			systemEventListenerClassTypeItemProvider = new SystemEventListenerClassTypeItemProvider(this);
-		}
-
-		return systemEventListenerClassTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected SystemEventListenerTypeItemProvider systemEventListenerTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createSystemEventListenerTypeAdapter() {
-		if (systemEventListenerTypeItemProvider == null) {
-			systemEventListenerTypeItemProvider = new SystemEventListenerTypeItemProvider(this);
-		}
-
-		return systemEventListenerTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.TagHandlerDelegateFactoryType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected TagHandlerDelegateFactoryTypeItemProvider tagHandlerDelegateFactoryTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.TagHandlerDelegateFactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createTagHandlerDelegateFactoryTypeAdapter() {
-		if (tagHandlerDelegateFactoryTypeItemProvider == null) {
-			tagHandlerDelegateFactoryTypeItemProvider = new TagHandlerDelegateFactoryTypeItemProvider(this);
-		}
-
-		return tagHandlerDelegateFactoryTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ToViewIdType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ToViewIdTypeItemProvider toViewIdTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ToViewIdType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createToViewIdTypeAdapter() {
-		if (toViewIdTypeItemProvider == null) {
-			toViewIdTypeItemProvider = new ToViewIdTypeItemProvider(this);
-		}
-
-		return toViewIdTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorClassType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ValidatorClassTypeItemProvider validatorClassTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorClassType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createValidatorClassTypeAdapter() {
-		if (validatorClassTypeItemProvider == null) {
-			validatorClassTypeItemProvider = new ValidatorClassTypeItemProvider(this);
-		}
-
-		return validatorClassTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorIdType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ValidatorIdTypeItemProvider validatorIdTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorIdType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createValidatorIdTypeAdapter() {
-		if (validatorIdTypeItemProvider == null) {
-			validatorIdTypeItemProvider = new ValidatorIdTypeItemProvider(this);
-		}
-
-		return validatorIdTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ValidatorTypeItemProvider validatorTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createValidatorTypeAdapter() {
-		if (validatorTypeItemProvider == null) {
-			validatorTypeItemProvider = new ValidatorTypeItemProvider(this);
-		}
-
-		return validatorTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ValueClassType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ValueClassTypeItemProvider valueClassTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ValueClassType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createValueClassTypeAdapter() {
-		if (valueClassTypeItemProvider == null) {
-			valueClassTypeItemProvider = new ValueClassTypeItemProvider(this);
-		}
-
-		return valueClassTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ValueType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ValueTypeItemProvider valueTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ValueType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createValueTypeAdapter() {
-		if (valueTypeItemProvider == null) {
-			valueTypeItemProvider = new ValueTypeItemProvider(this);
-		}
-
-		return valueTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.VariableResolverType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected VariableResolverTypeItemProvider variableResolverTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.VariableResolverType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createVariableResolverTypeAdapter() {
-		if (variableResolverTypeItemProvider == null) {
-			variableResolverTypeItemProvider = new VariableResolverTypeItemProvider(this);
-		}
-
-		return variableResolverTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ViewHandlerType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ViewHandlerTypeItemProvider viewHandlerTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ViewHandlerType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createViewHandlerTypeAdapter() {
-		if (viewHandlerTypeItemProvider == null) {
-			viewHandlerTypeItemProvider = new ViewHandlerTypeItemProvider(this);
-		}
-
-		return viewHandlerTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationExtensionType} instances.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected ApplicationExtensionTypeItemProvider applicationExtensionTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationExtensionType}.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Adapter createApplicationExtensionTypeAdapter() {
-		if (applicationExtensionTypeItemProvider == null) {
-			applicationExtensionTypeItemProvider = new ApplicationExtensionTypeItemProvider(this);
-		}
-
-		return applicationExtensionTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ConverterExtensionType} instances.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected ConverterExtensionTypeItemProvider converterExtensionTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ConverterExtensionType}.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Adapter createConverterExtensionTypeAdapter() {
-		if (converterExtensionTypeItemProvider == null) {
-			converterExtensionTypeItemProvider = new ConverterExtensionTypeItemProvider(this);
-		}
-
-		return converterExtensionTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType} instances.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected ResourceBundleTypeItemProvider resourceBundleTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType}.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Adapter createResourceBundleTypeAdapter() {
-		if (resourceBundleTypeItemProvider == null) {
-			resourceBundleTypeItemProvider = new ResourceBundleTypeItemProvider(this);
-		}
-
-		return resourceBundleTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.BaseNameType} instances.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected BaseNameTypeItemProvider baseNameTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.BaseNameType}.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Adapter createBaseNameTypeAdapter() {
-		if (baseNameTypeItemProvider == null) {
-			baseNameTypeItemProvider = new BaseNameTypeItemProvider(this);
-		}
-
-		return baseNameTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.VarType} instances.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected VarTypeItemProvider varTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.VarType}.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Adapter createVarTypeAdapter() {
-		if (varTypeItemProvider == null) {
-			varTypeItemProvider = new VarTypeItemProvider(this);
-		}
-
-		return varTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ViewDeclarationLanguageFactoryType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ViewDeclarationLanguageFactoryTypeItemProvider viewDeclarationLanguageFactoryTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ViewDeclarationLanguageFactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createViewDeclarationLanguageFactoryTypeAdapter() {
-		if (viewDeclarationLanguageFactoryTypeItemProvider == null) {
-			viewDeclarationLanguageFactoryTypeItemProvider = new ViewDeclarationLanguageFactoryTypeItemProvider(this);
-		}
-
-		return viewDeclarationLanguageFactoryTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.VisitContextFactoryType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected VisitContextFactoryTypeItemProvider visitContextFactoryTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.VisitContextFactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createVisitContextFactoryTypeAdapter() {
-		if (visitContextFactoryTypeItemProvider == null) {
-			visitContextFactoryTypeItemProvider = new VisitContextFactoryTypeItemProvider(this);
-		}
-
-		return visitContextFactoryTypeItemProvider;
-	}
-
-				/**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitExtensionType} instances.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected RenderKitExtensionTypeItemProvider renderKitExtensionTypeItemProvider;
-
-    /**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitExtensionType}.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Adapter createRenderKitExtensionTypeAdapter() {
-		if (renderKitExtensionTypeItemProvider == null) {
-			renderKitExtensionTypeItemProvider = new RenderKitExtensionTypeItemProvider(this);
-		}
-
-		return renderKitExtensionTypeItemProvider;
-	}
-
-    /**
-	 * This keeps track of the one adapter used for all {@link org.eclipse.jst.jsf.facesconfig.emf.ResourceHandlerType} instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ResourceHandlerTypeItemProvider resourceHandlerTypeItemProvider;
-
-				/**
-	 * This creates an adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ResourceHandlerType}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Adapter createResourceHandlerTypeAdapter() {
-		if (resourceHandlerTypeItemProvider == null) {
-			resourceHandlerTypeItemProvider = new ResourceHandlerTypeItemProvider(this);
-		}
-
-		return resourceHandlerTypeItemProvider;
-	}
-
-				/**
-	 * 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
-	 */
-	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
-	 */
-	public Adapter adapt(Notifier notifier, Object type) {
-		return super.adapt(notifier, this);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 (absoluteOrderingTypeItemProvider != null) absoluteOrderingTypeItemProvider.dispose();
-		if (actionListenerTypeItemProvider != null) actionListenerTypeItemProvider.dispose();
-		if (applicationFactoryTypeItemProvider != null) applicationFactoryTypeItemProvider.dispose();
-		if (applicationTypeItemProvider != null) applicationTypeItemProvider.dispose();
-		if (applicationExtensionTypeItemProvider != null) applicationExtensionTypeItemProvider.dispose();
-		if (attributeClassTypeItemProvider != null) attributeClassTypeItemProvider.dispose();
-		if (attributeExtensionTypeItemProvider != null) attributeExtensionTypeItemProvider.dispose();
-		if (attributeNameTypeItemProvider != null) attributeNameTypeItemProvider.dispose();
-		if (attributeTypeItemProvider != null) attributeTypeItemProvider.dispose();
-		if (behaviorClassTypeItemProvider != null) behaviorClassTypeItemProvider.dispose();
-		if (behaviorIdTypeItemProvider != null) behaviorIdTypeItemProvider.dispose();
-		if (behaviorTypeItemProvider != null) behaviorTypeItemProvider.dispose();
-		if (behaviorExtensionTypeItemProvider != null) behaviorExtensionTypeItemProvider.dispose();
-		if (clientBehaviorRendererClassTypeItemProvider != null) clientBehaviorRendererClassTypeItemProvider.dispose();
-		if (clientBehaviorRendererTypeItemProvider != null) clientBehaviorRendererTypeItemProvider.dispose();
-		if (clientBehaviorRendererTypeTypeItemProvider != null) clientBehaviorRendererTypeTypeItemProvider.dispose();
-		if (componentClassTypeItemProvider != null) componentClassTypeItemProvider.dispose();
-		if (componentExtensionTypeItemProvider != null) componentExtensionTypeItemProvider.dispose();
-		if (componentFamilyTypeItemProvider != null) componentFamilyTypeItemProvider.dispose();
-		if (componentTypeItemProvider != null) componentTypeItemProvider.dispose();
-		if (componentTypeTypeItemProvider != null) componentTypeTypeItemProvider.dispose();
-		if (converterClassTypeItemProvider != null) converterClassTypeItemProvider.dispose();
-		if (converterForClassTypeItemProvider != null) converterForClassTypeItemProvider.dispose();
-		if (converterIdTypeItemProvider != null) converterIdTypeItemProvider.dispose();
-		if (converterTypeItemProvider != null) converterTypeItemProvider.dispose();
-		if (converterExtensionTypeItemProvider != null) converterExtensionTypeItemProvider.dispose();
-		if (defaultLocaleTypeItemProvider != null) defaultLocaleTypeItemProvider.dispose();
-		if (defaultRenderKitIdTypeItemProvider != null) defaultRenderKitIdTypeItemProvider.dispose();
-		if (defaultValidatorsTypeItemProvider != null) defaultValidatorsTypeItemProvider.dispose();
-		if (defaultValueTypeItemProvider != null) defaultValueTypeItemProvider.dispose();
-		if (descriptionTypeItemProvider != null) descriptionTypeItemProvider.dispose();
-		if (displayNameTypeItemProvider != null) displayNameTypeItemProvider.dispose();
-		if (documentRootItemProvider != null) documentRootItemProvider.dispose();
-		if (dynamicAttributeItemProvider != null) dynamicAttributeItemProvider.dispose();
-		if (dynamicElementItemProvider != null) dynamicElementItemProvider.dispose();
-		if (elResolverTypeItemProvider != null) elResolverTypeItemProvider.dispose();
-		if (exceptionHandlerFactoryTypeItemProvider != null) exceptionHandlerFactoryTypeItemProvider.dispose();
-		if (externalContextFactoryTypeItemProvider != null) externalContextFactoryTypeItemProvider.dispose();
-		if (facesConfigTypeItemProvider != null) facesConfigTypeItemProvider.dispose();
-		if (facesConfigExtensionTypeItemProvider != null) facesConfigExtensionTypeItemProvider.dispose();
-		if (facesContextFactoryTypeItemProvider != null) facesContextFactoryTypeItemProvider.dispose();
-		if (facetExtensionTypeItemProvider != null) facetExtensionTypeItemProvider.dispose();
-		if (facetNameTypeItemProvider != null) facetNameTypeItemProvider.dispose();
-		if (facetTypeItemProvider != null) facetTypeItemProvider.dispose();
-		if (factoryTypeItemProvider != null) factoryTypeItemProvider.dispose();
-		if (factoryExtensionTypeItemProvider != null) factoryExtensionTypeItemProvider.dispose();
-		if (fromActionTypeItemProvider != null) fromActionTypeItemProvider.dispose();
-		if (fromOutcomeTypeItemProvider != null) fromOutcomeTypeItemProvider.dispose();
-		if (fromViewIdTypeItemProvider != null) fromViewIdTypeItemProvider.dispose();
-		if (iconTypeItemProvider != null) iconTypeItemProvider.dispose();
-		if (ifTypeItemProvider != null) ifTypeItemProvider.dispose();
-		if (keyClassTypeItemProvider != null) keyClassTypeItemProvider.dispose();
-		if (keyTypeItemProvider != null) keyTypeItemProvider.dispose();
-		if (largeIconTypeItemProvider != null) largeIconTypeItemProvider.dispose();
-		if (lifecycleFactoryTypeItemProvider != null) lifecycleFactoryTypeItemProvider.dispose();
-		if (lifecycleTypeItemProvider != null) lifecycleTypeItemProvider.dispose();
-		if (lifecycleExtensionTypeItemProvider != null) lifecycleExtensionTypeItemProvider.dispose();
-		if (listEntriesTypeItemProvider != null) listEntriesTypeItemProvider.dispose();
-		if (localeConfigTypeItemProvider != null) localeConfigTypeItemProvider.dispose();
-		if (managedBeanClassTypeItemProvider != null) managedBeanClassTypeItemProvider.dispose();
-		if (managedBeanNameTypeItemProvider != null) managedBeanNameTypeItemProvider.dispose();
-		if (managedBeanScopeTypeItemProvider != null) managedBeanScopeTypeItemProvider.dispose();
-		if (managedBeanTypeItemProvider != null) managedBeanTypeItemProvider.dispose();
-		if (managedBeanExtensionTypeItemProvider != null) managedBeanExtensionTypeItemProvider.dispose();
-		if (managedPropertyTypeItemProvider != null) managedPropertyTypeItemProvider.dispose();
-		if (mapEntriesTypeItemProvider != null) mapEntriesTypeItemProvider.dispose();
-		if (mapEntryTypeItemProvider != null) mapEntryTypeItemProvider.dispose();
-		if (messageBundleTypeItemProvider != null) messageBundleTypeItemProvider.dispose();
-		if (nameTypeItemProvider != null) nameTypeItemProvider.dispose();
-		if (navigationCaseTypeItemProvider != null) navigationCaseTypeItemProvider.dispose();
-		if (navigationHandlerTypeItemProvider != null) navigationHandlerTypeItemProvider.dispose();
-		if (navigationRuleTypeItemProvider != null) navigationRuleTypeItemProvider.dispose();
-		if (navigationRuleExtensionTypeItemProvider != null) navigationRuleExtensionTypeItemProvider.dispose();
-		if (nullValueTypeItemProvider != null) nullValueTypeItemProvider.dispose();
-		if (orderingTypeItemProvider != null) orderingTypeItemProvider.dispose();
-		if (orderingOrderingTypeItemProvider != null) orderingOrderingTypeItemProvider.dispose();
-		if (orderingOthersTypeItemProvider != null) orderingOthersTypeItemProvider.dispose();
-		if (partialViewContextFactoryTypeItemProvider != null) partialViewContextFactoryTypeItemProvider.dispose();
-		if (phaseListenerTypeItemProvider != null) phaseListenerTypeItemProvider.dispose();
-		if (propertyClassTypeItemProvider != null) propertyClassTypeItemProvider.dispose();
-		if (propertyExtensionTypeItemProvider != null) propertyExtensionTypeItemProvider.dispose();
-		if (propertyNameTypeItemProvider != null) propertyNameTypeItemProvider.dispose();
-		if (propertyResolverTypeItemProvider != null) propertyResolverTypeItemProvider.dispose();
-		if (propertyTypeItemProvider != null) propertyTypeItemProvider.dispose();
-		if (redirectTypeItemProvider != null) redirectTypeItemProvider.dispose();
-		if (redirectViewParamTypeItemProvider != null) redirectViewParamTypeItemProvider.dispose();
-		if (referencedBeanClassTypeItemProvider != null) referencedBeanClassTypeItemProvider.dispose();
-		if (referencedBeanNameTypeItemProvider != null) referencedBeanNameTypeItemProvider.dispose();
-		if (referencedBeanTypeItemProvider != null) referencedBeanTypeItemProvider.dispose();
-		if (rendererClassTypeItemProvider != null) rendererClassTypeItemProvider.dispose();
-		if (rendererExtensionTypeItemProvider != null) rendererExtensionTypeItemProvider.dispose();
-		if (rendererTypeItemProvider != null) rendererTypeItemProvider.dispose();
-		if (rendererTypeTypeItemProvider != null) rendererTypeTypeItemProvider.dispose();
-		if (renderKitClassTypeItemProvider != null) renderKitClassTypeItemProvider.dispose();
-		if (renderKitFactoryTypeItemProvider != null) renderKitFactoryTypeItemProvider.dispose();
-		if (renderKitIdTypeItemProvider != null) renderKitIdTypeItemProvider.dispose();
-		if (renderKitTypeItemProvider != null) renderKitTypeItemProvider.dispose();
-		if (renderKitExtensionTypeItemProvider != null) renderKitExtensionTypeItemProvider.dispose();
-		if (resourceHandlerTypeItemProvider != null) resourceHandlerTypeItemProvider.dispose();
-		if (smallIconTypeItemProvider != null) smallIconTypeItemProvider.dispose();
-		if (sourceClassTypeItemProvider != null) sourceClassTypeItemProvider.dispose();
-		if (stateManagerTypeItemProvider != null) stateManagerTypeItemProvider.dispose();
-		if (suggestedValueTypeItemProvider != null) suggestedValueTypeItemProvider.dispose();
-		if (supportedLocaleTypeItemProvider != null) supportedLocaleTypeItemProvider.dispose();
-		if (systemEventClassTypeItemProvider != null) systemEventClassTypeItemProvider.dispose();
-		if (systemEventListenerClassTypeItemProvider != null) systemEventListenerClassTypeItemProvider.dispose();
-		if (systemEventListenerTypeItemProvider != null) systemEventListenerTypeItemProvider.dispose();
-		if (tagHandlerDelegateFactoryTypeItemProvider != null) tagHandlerDelegateFactoryTypeItemProvider.dispose();
-		if (toViewIdTypeItemProvider != null) toViewIdTypeItemProvider.dispose();
-		if (validatorClassTypeItemProvider != null) validatorClassTypeItemProvider.dispose();
-		if (validatorIdTypeItemProvider != null) validatorIdTypeItemProvider.dispose();
-		if (validatorTypeItemProvider != null) validatorTypeItemProvider.dispose();
-		if (validatorExtensionTypeItemProvider != null) validatorExtensionTypeItemProvider.dispose();
-		if (valueClassTypeItemProvider != null) valueClassTypeItemProvider.dispose();
-		if (valueTypeItemProvider != null) valueTypeItemProvider.dispose();
-		if (variableResolverTypeItemProvider != null) variableResolverTypeItemProvider.dispose();
-		if (viewHandlerTypeItemProvider != null) viewHandlerTypeItemProvider.dispose();
-		if (resourceBundleTypeItemProvider != null) resourceBundleTypeItemProvider.dispose();
-		if (baseNameTypeItemProvider != null) baseNameTypeItemProvider.dispose();
-		if (varTypeItemProvider != null) varTypeItemProvider.dispose();
-		if (viewDeclarationLanguageFactoryTypeItemProvider != null) viewDeclarationLanguageFactoryTypeItemProvider.dispose();
-		if (visitContextFactoryTypeItemProvider != null) visitContextFactoryTypeItemProvider.dispose();
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacesConfigTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacesConfigTypeItemProvider.java
deleted file mode 100644
index 6160d6f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacesConfigTypeItemProvider.java
+++ /dev/null
@@ -1,370 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class FacesConfigTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FacesConfigTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addFacesConfigExtensionPropertyDescriptor(object);
-			addXmlnsPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-			addMetadataCompletePropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Faces Config Extension feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addFacesConfigExtensionPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_FacesConfigType_facesConfigExtension_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_FacesConfigType_facesConfigExtension_feature", "_UI_FacesConfigType_type"),
-				 FacesConfigPackage.Literals.FACES_CONFIG_TYPE__FACES_CONFIG_EXTENSION,
-				 true,
-				 false,
-				 true,
-				 null,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Xmlns feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addXmlnsPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_FacesConfigType_xmlns_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_FacesConfigType_xmlns_feature", "_UI_FacesConfigType_type"),
-				 FacesConfigPackage.Literals.FACES_CONFIG_TYPE__XMLNS,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_FacesConfigType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_FacesConfigType_id_feature", "_UI_FacesConfigType_type"),
-				 FacesConfigPackage.Literals.FACES_CONFIG_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Metadata Complete feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addMetadataCompletePropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_FacesConfigType_metadataComplete_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_FacesConfigType_metadataComplete_feature", "_UI_FacesConfigType_type"),
-				 FacesConfigPackage.Literals.FACES_CONFIG_TYPE__METADATA_COMPLETE,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-				/**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__APPLICATION);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__ORDERING);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__ABSOLUTE_ORDERING);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__FACTORY);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__COMPONENT);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__CONVERTER);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__MANAGED_BEAN);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__NAVIGATION_RULE);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__REFERENCED_BEAN);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__RENDER_KIT);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__LIFECYCLE);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__VALIDATOR);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__BEHAVIOR);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 FacesConfigType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/FacesConfigType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((FacesConfigType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_FacesConfigType_type") :
-			getString("_UI_FacesConfigType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(FacesConfigType.class)) {
-			case FacesConfigPackage.FACES_CONFIG_TYPE__XMLNS:
-			case FacesConfigPackage.FACES_CONFIG_TYPE__ID:
-			case FacesConfigPackage.FACES_CONFIG_TYPE__METADATA_COMPLETE:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__APPLICATION:
-			case FacesConfigPackage.FACES_CONFIG_TYPE__ORDERING:
-			case FacesConfigPackage.FACES_CONFIG_TYPE__ABSOLUTE_ORDERING:
-			case FacesConfigPackage.FACES_CONFIG_TYPE__FACTORY:
-			case FacesConfigPackage.FACES_CONFIG_TYPE__COMPONENT:
-			case FacesConfigPackage.FACES_CONFIG_TYPE__CONVERTER:
-			case FacesConfigPackage.FACES_CONFIG_TYPE__MANAGED_BEAN:
-			case FacesConfigPackage.FACES_CONFIG_TYPE__NAME:
-			case FacesConfigPackage.FACES_CONFIG_TYPE__NAVIGATION_RULE:
-			case FacesConfigPackage.FACES_CONFIG_TYPE__REFERENCED_BEAN:
-			case FacesConfigPackage.FACES_CONFIG_TYPE__RENDER_KIT:
-			case FacesConfigPackage.FACES_CONFIG_TYPE__LIFECYCLE:
-			case FacesConfigPackage.FACES_CONFIG_TYPE__VALIDATOR:
-			case FacesConfigPackage.FACES_CONFIG_TYPE__BEHAVIOR:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__APPLICATION,
-				 FacesConfigFactory.eINSTANCE.createApplicationType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__ORDERING,
-				 FacesConfigFactory.eINSTANCE.createOrderingType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__ABSOLUTE_ORDERING,
-				 FacesConfigFactory.eINSTANCE.createAbsoluteOrderingType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__FACTORY,
-				 FacesConfigFactory.eINSTANCE.createFactoryType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__COMPONENT,
-				 FacesConfigFactory.eINSTANCE.createComponentType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__CONVERTER,
-				 FacesConfigFactory.eINSTANCE.createConverterType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__MANAGED_BEAN,
-				 FacesConfigFactory.eINSTANCE.createManagedBeanType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__NAME,
-				 FacesConfigFactory.eINSTANCE.createNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__NAVIGATION_RULE,
-				 FacesConfigFactory.eINSTANCE.createNavigationRuleType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__REFERENCED_BEAN,
-				 FacesConfigFactory.eINSTANCE.createReferencedBeanType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__RENDER_KIT,
-				 FacesConfigFactory.eINSTANCE.createRenderKitType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__LIFECYCLE,
-				 FacesConfigFactory.eINSTANCE.createLifecycleType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__VALIDATOR,
-				 FacesConfigFactory.eINSTANCE.createValidatorType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACES_CONFIG_TYPE__BEHAVIOR,
-				 FacesConfigFactory.eINSTANCE.createBehaviorType()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacesContextFactoryTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacesContextFactoryTypeItemProvider.java
deleted file mode 100644
index 2fe6e23..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacesContextFactoryTypeItemProvider.java
+++ /dev/null
@@ -1,209 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesContextFactoryType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FacesContextFactoryType} object.
- * <!-- begin-user-doc --> 
- * @extends ITableItemLabelProvider 
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class FacesContextFactoryTypeItemProvider extends ItemProviderAdapter
-		implements IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider{
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc --> 
-	 * @param adapterFactory
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FacesContextFactoryTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc --> 
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_FacesContextFactoryType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_FacesContextFactoryType_textContent_feature", "_UI_FacesContextFactoryType_type"),
-				 FacesConfigPackage.Literals.FACES_CONTEXT_FACTORY_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc--> 
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_FacesContextFactoryType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_FacesContextFactoryType_id_feature", "_UI_FacesContextFactoryType_type"),
-				 FacesConfigPackage.Literals.FACES_CONTEXT_FACTORY_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns FacesContextFactoryType.gif.
-	 * <!-- begin-user-doc --> <!--
-	 * end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/FacesContextFactoryType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc
-	 * --> <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((FacesContextFactoryType) object).getTextContent();
-		return label == null || label.length() == 0 ? getString("_UI_FacesContextFactoryType_type")
-				: label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(FacesContextFactoryType.class)) {
-			case FacesConfigPackage.FACES_CONTEXT_FACTORY_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.FACES_CONTEXT_FACTORY_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_FacesContextFactoryType_type"); //$NON-NLS-1$
-		}
-
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacetExtensionTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacetExtensionTypeItemProvider.java
deleted file mode 100644
index 913fa62..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacetExtensionTypeItemProvider.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.edit.provider.IEditingDomainItemProvider;
-import org.eclipse.emf.edit.provider.IItemLabelProvider;
-import org.eclipse.emf.edit.provider.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.jst.jsf.facesconfig.emf.FacetExtensionType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FacetExtensionType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public class FacetExtensionTypeItemProvider
-	extends ExtensionTypeItemProvider
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FacetExtensionTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This returns FacetExtensionType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/FacetExtensionType")); //$NON-NLS-1$
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((FacetExtensionType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_FacetExtensionType_type") : //$NON-NLS-1$
-			getString("_UI_FacetExtensionType_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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-		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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacetNameTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacetNameTypeItemProvider.java
deleted file mode 100644
index a7e1a60..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacetNameTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FacetNameType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FacetNameType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class FacetNameTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FacetNameTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_FacetNameType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_FacetNameType_textContent_feature", "_UI_FacetNameType_type"),
-				 FacesConfigPackage.Literals.FACET_NAME_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_FacetNameType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_FacetNameType_id_feature", "_UI_FacetNameType_type"),
-				 FacesConfigPackage.Literals.FACET_NAME_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns FacetNameType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/FacetNameType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((FacetNameType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_FacetNameType_type") :
-			getString("_UI_FacetNameType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(FacetNameType.class)) {
-			case FacesConfigPackage.FACET_NAME_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.FACET_NAME_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacetTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacetTypeItemProvider.java
deleted file mode 100644
index d060438..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FacetTypeItemProvider.java
+++ /dev/null
@@ -1,259 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.DescriptionType;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FacetType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FacetType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class FacetTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource,
-		ITableItemLabelProvider{
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FacetTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_FacetType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_FacetType_id_feature", "_UI_FacetType_type"),
-				 FacesConfigPackage.Literals.FACET_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACET_TYPE__DESCRIPTION);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACET_TYPE__DISPLAY_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACET_TYPE__ICON);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACET_TYPE__FACET_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACET_TYPE__FACET_EXTENSION);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 FacetType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/FacetType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((FacetType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_FacetType_type") :
-			getString("_UI_FacetType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(FacetType.class)) {
-			case FacesConfigPackage.FACET_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.FACET_TYPE__DESCRIPTION:
-			case FacesConfigPackage.FACET_TYPE__DISPLAY_NAME:
-			case FacesConfigPackage.FACET_TYPE__ICON:
-			case FacesConfigPackage.FACET_TYPE__FACET_NAME:
-			case FacesConfigPackage.FACET_TYPE__FACET_EXTENSION:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACET_TYPE__DESCRIPTION,
-				 FacesConfigFactory.eINSTANCE.createDescriptionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACET_TYPE__DISPLAY_NAME,
-				 FacesConfigFactory.eINSTANCE.createDisplayNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACET_TYPE__ICON,
-				 FacesConfigFactory.eINSTANCE.createIconType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACET_TYPE__FACET_NAME,
-				 FacesConfigFactory.eINSTANCE.createFacetNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACET_TYPE__FACET_EXTENSION,
-				 FacesConfigFactory.eINSTANCE.createFacetExtensionType()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	public String getColumnText(Object object, int columnIndex) {
-		FacetType facet = (FacetType) object;
-		switch (columnIndex) {
-
-		case 0:
-			return facet.getFacetName() == null ? "" : facet.getFacetName() //$NON-NLS-1$
-					.getTextContent();
-		case 1:
-			return facet.getDisplayName().size() > 0 ? ((DisplayNameType) facet
-					.getDisplayName().get(0)).getTextContent() : ""; //$NON-NLS-1$
-		case 2:
-			return facet.getDescription().size() > 0 ? ((DescriptionType) facet
-					.getDescription().get(0)).getTextContent() : ""; //$NON-NLS-1$
-		}
-		return null;
-	}
-
-	public Object getColumnImage(Object object, int columnIndex) {
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FactoryExtensionTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FactoryExtensionTypeItemProvider.java
deleted file mode 100644
index 20b75ac..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FactoryExtensionTypeItemProvider.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.edit.provider.IEditingDomainItemProvider;
-import org.eclipse.emf.edit.provider.IItemLabelProvider;
-import org.eclipse.emf.edit.provider.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.jst.jsf.facesconfig.emf.FactoryExtensionType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FactoryExtensionType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public class FactoryExtensionTypeItemProvider
-    extends ExtensionTypeItemProvider
-    implements	
-        IEditingDomainItemProvider,	
-        IStructuredItemContentProvider,	
-        ITreeItemContentProvider,	
-        IItemLabelProvider,	
-        IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    @SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public FactoryExtensionTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This returns FactoryExtensionType.gif.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-    public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/FactoryExtensionType")); //$NON-NLS-1$
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-    public String getText(Object object) {
-		String label = ((FactoryExtensionType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_FactoryExtensionType_type") : //$NON-NLS-1$
-			getString("_UI_FactoryExtensionType_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
-	 */
-    public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-		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
-	 */
-    protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FactoryTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FactoryTypeItemProvider.java
deleted file mode 100644
index 3b64b58..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FactoryTypeItemProvider.java
+++ /dev/null
@@ -1,292 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FactoryType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class FactoryTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FactoryTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addFactoryExtensionPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Factory Extension feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addFactoryExtensionPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_FactoryType_factoryExtension_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_FactoryType_factoryExtension_feature", "_UI_FactoryType_type"),
-				 FacesConfigPackage.Literals.FACTORY_TYPE__FACTORY_EXTENSION,
-				 true,
-				 false,
-				 true,
-				 null,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_FactoryType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_FactoryType_id_feature", "_UI_FactoryType_type"),
-				 FacesConfigPackage.Literals.FACTORY_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACTORY_TYPE__APPLICATION_FACTORY);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACTORY_TYPE__EXCEPTION_HANDLER_FACTORY);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACTORY_TYPE__EXTERNAL_CONTEXT_FACTORY);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACTORY_TYPE__FACES_CONTEXT_FACTORY);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACTORY_TYPE__PARTIAL_VIEW_CONTEXT_FACTORY);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACTORY_TYPE__LIFECYCLE_FACTORY);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACTORY_TYPE__VIEW_DECLARATION_LANGUAGE_FACTORY);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACTORY_TYPE__TAG_HANDLER_DELEGATE_FACTORY);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACTORY_TYPE__RENDER_KIT_FACTORY);
-			childrenFeatures.add(FacesConfigPackage.Literals.FACTORY_TYPE__VISIT_CONTEXT_FACTORY);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 FactoryType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/FactoryType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((FactoryType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_FactoryType_type") :
-			getString("_UI_FactoryType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(FactoryType.class)) {
-			case FacesConfigPackage.FACTORY_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__APPLICATION_FACTORY:
-			case FacesConfigPackage.FACTORY_TYPE__EXCEPTION_HANDLER_FACTORY:
-			case FacesConfigPackage.FACTORY_TYPE__EXTERNAL_CONTEXT_FACTORY:
-			case FacesConfigPackage.FACTORY_TYPE__FACES_CONTEXT_FACTORY:
-			case FacesConfigPackage.FACTORY_TYPE__PARTIAL_VIEW_CONTEXT_FACTORY:
-			case FacesConfigPackage.FACTORY_TYPE__LIFECYCLE_FACTORY:
-			case FacesConfigPackage.FACTORY_TYPE__VIEW_DECLARATION_LANGUAGE_FACTORY:
-			case FacesConfigPackage.FACTORY_TYPE__TAG_HANDLER_DELEGATE_FACTORY:
-			case FacesConfigPackage.FACTORY_TYPE__RENDER_KIT_FACTORY:
-			case FacesConfigPackage.FACTORY_TYPE__VISIT_CONTEXT_FACTORY:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACTORY_TYPE__APPLICATION_FACTORY,
-				 FacesConfigFactory.eINSTANCE.createApplicationFactoryType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACTORY_TYPE__EXCEPTION_HANDLER_FACTORY,
-				 FacesConfigFactory.eINSTANCE.createExceptionHandlerFactoryType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACTORY_TYPE__EXTERNAL_CONTEXT_FACTORY,
-				 FacesConfigFactory.eINSTANCE.createExternalContextFactoryType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACTORY_TYPE__FACES_CONTEXT_FACTORY,
-				 FacesConfigFactory.eINSTANCE.createFacesContextFactoryType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACTORY_TYPE__PARTIAL_VIEW_CONTEXT_FACTORY,
-				 FacesConfigFactory.eINSTANCE.createPartialViewContextFactoryType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACTORY_TYPE__LIFECYCLE_FACTORY,
-				 FacesConfigFactory.eINSTANCE.createLifecycleFactoryType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACTORY_TYPE__VIEW_DECLARATION_LANGUAGE_FACTORY,
-				 FacesConfigFactory.eINSTANCE.createViewDeclarationLanguageFactoryType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACTORY_TYPE__TAG_HANDLER_DELEGATE_FACTORY,
-				 FacesConfigFactory.eINSTANCE.createTagHandlerDelegateFactoryType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACTORY_TYPE__RENDER_KIT_FACTORY,
-				 FacesConfigFactory.eINSTANCE.createRenderKitFactoryType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.FACTORY_TYPE__VISIT_CONTEXT_FACTORY,
-				 FacesConfigFactory.eINSTANCE.createVisitContextFactoryType()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FromActionTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FromActionTypeItemProvider.java
deleted file mode 100644
index eb0491d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FromActionTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FromActionType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FromActionType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class FromActionTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FromActionTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_FromActionType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_FromActionType_textContent_feature", "_UI_FromActionType_type"),
-				 FacesConfigPackage.Literals.FROM_ACTION_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_FromActionType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_FromActionType_id_feature", "_UI_FromActionType_type"),
-				 FacesConfigPackage.Literals.FROM_ACTION_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns FromActionType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/FromActionType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((FromActionType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_FromActionType_type") :
-			getString("_UI_FromActionType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(FromActionType.class)) {
-			case FacesConfigPackage.FROM_ACTION_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.FROM_ACTION_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FromOutcomeTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FromOutcomeTypeItemProvider.java
deleted file mode 100644
index 5ec950b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FromOutcomeTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FromOutcomeType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FromOutcomeType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class FromOutcomeTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FromOutcomeTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_FromOutcomeType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_FromOutcomeType_textContent_feature", "_UI_FromOutcomeType_type"),
-				 FacesConfigPackage.Literals.FROM_OUTCOME_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_FromOutcomeType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_FromOutcomeType_id_feature", "_UI_FromOutcomeType_type"),
-				 FacesConfigPackage.Literals.FROM_OUTCOME_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns FromOutcomeType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/FromOutcomeType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((FromOutcomeType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_FromOutcomeType_type") :
-			getString("_UI_FromOutcomeType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(FromOutcomeType.class)) {
-			case FacesConfigPackage.FROM_OUTCOME_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.FROM_OUTCOME_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FromViewIdTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FromViewIdTypeItemProvider.java
deleted file mode 100644
index 06d9901..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/FromViewIdTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FromViewIdType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.FromViewIdType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class FromViewIdTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FromViewIdTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_FromViewIdType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_FromViewIdType_textContent_feature", "_UI_FromViewIdType_type"),
-				 FacesConfigPackage.Literals.FROM_VIEW_ID_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_FromViewIdType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_FromViewIdType_id_feature", "_UI_FromViewIdType_type"),
-				 FacesConfigPackage.Literals.FROM_VIEW_ID_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns FromViewIdType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/FromViewIdType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((FromViewIdType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_FromViewIdType_type") :
-			getString("_UI_FromViewIdType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(FromViewIdType.class)) {
-			case FacesConfigPackage.FROM_VIEW_ID_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.FROM_VIEW_ID_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/IconTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/IconTypeItemProvider.java
deleted file mode 100644
index 0f4ad44..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/IconTypeItemProvider.java
+++ /dev/null
@@ -1,237 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.IconType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.IconType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class IconTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public IconTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addLangPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Lang feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addLangPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_IconType_lang_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_IconType_lang_feature", "_UI_IconType_type"),
-				 FacesConfigPackage.Literals.ICON_TYPE__LANG,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_IconType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_IconType_id_feature", "_UI_IconType_type"),
-				 FacesConfigPackage.Literals.ICON_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.ICON_TYPE__SMALL_ICON);
-			childrenFeatures.add(FacesConfigPackage.Literals.ICON_TYPE__LARGE_ICON);
-		}
-		return childrenFeatures;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 IconType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/IconType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((IconType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_IconType_type") :
-			getString("_UI_IconType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(IconType.class)) {
-			case FacesConfigPackage.ICON_TYPE__LANG:
-			case FacesConfigPackage.ICON_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.ICON_TYPE__SMALL_ICON:
-			case FacesConfigPackage.ICON_TYPE__LARGE_ICON:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.ICON_TYPE__SMALL_ICON,
-				 FacesConfigFactory.eINSTANCE.createSmallIconType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.ICON_TYPE__LARGE_ICON,
-				 FacesConfigFactory.eINSTANCE.createLargeIconType()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/IfTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/IfTypeItemProvider.java
deleted file mode 100644
index 37a725c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/IfTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.IfType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.IfType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class IfTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public IfTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc --> 
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_IfType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_IfType_textContent_feature", "_UI_IfType_type"),
-				 FacesConfigPackage.Literals.IF_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc --> 
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_IfType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_IfType_id_feature", "_UI_IfType_type"),
-				 FacesConfigPackage.Literals.IF_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This returns IfType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/IfType"));
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((IfType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_IfType_type") :
-			getString("_UI_IfType_type") + " " + label;
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(IfType.class)) {
-			case FacesConfigPackage.IF_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.IF_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/KeyClassTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/KeyClassTypeItemProvider.java
deleted file mode 100644
index 264b281..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/KeyClassTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.KeyClassType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.KeyClassType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class KeyClassTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public KeyClassTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_KeyClassType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_KeyClassType_textContent_feature", "_UI_KeyClassType_type"),
-				 FacesConfigPackage.Literals.KEY_CLASS_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_KeyClassType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_KeyClassType_id_feature", "_UI_KeyClassType_type"),
-				 FacesConfigPackage.Literals.KEY_CLASS_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns KeyClassType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/KeyClassType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((KeyClassType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_KeyClassType_type") :
-			getString("_UI_KeyClassType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(KeyClassType.class)) {
-			case FacesConfigPackage.KEY_CLASS_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.KEY_CLASS_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/KeyTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/KeyTypeItemProvider.java
deleted file mode 100644
index 62c5d35..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/KeyTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.KeyType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.KeyType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class KeyTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public KeyTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_KeyType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_KeyType_textContent_feature", "_UI_KeyType_type"),
-				 FacesConfigPackage.Literals.KEY_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_KeyType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_KeyType_id_feature", "_UI_KeyType_type"),
-				 FacesConfigPackage.Literals.KEY_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns KeyType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/KeyType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((KeyType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_KeyType_type") :
-			getString("_UI_KeyType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(KeyType.class)) {
-			case FacesConfigPackage.KEY_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.KEY_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/LargeIconTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/LargeIconTypeItemProvider.java
deleted file mode 100644
index caca793..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/LargeIconTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.LargeIconType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.LargeIconType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class LargeIconTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public LargeIconTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_LargeIconType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_LargeIconType_textContent_feature", "_UI_LargeIconType_type"),
-				 FacesConfigPackage.Literals.LARGE_ICON_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_LargeIconType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_LargeIconType_id_feature", "_UI_LargeIconType_type"),
-				 FacesConfigPackage.Literals.LARGE_ICON_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns LargeIconType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/LargeIconType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((LargeIconType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_LargeIconType_type") :
-			getString("_UI_LargeIconType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(LargeIconType.class)) {
-			case FacesConfigPackage.LARGE_ICON_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.LARGE_ICON_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/LifecycleExtensionTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/LifecycleExtensionTypeItemProvider.java
deleted file mode 100644
index fa06c39..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/LifecycleExtensionTypeItemProvider.java
+++ /dev/null
@@ -1,145 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.edit.provider.IEditingDomainItemProvider;
-import org.eclipse.emf.edit.provider.IItemLabelProvider;
-import org.eclipse.emf.edit.provider.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.jst.jsf.facesconfig.emf.LifecycleExtensionType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleExtensionType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class LifecycleExtensionTypeItemProvider
-    extends ExtensionTypeItemProvider
-    implements	
-        IEditingDomainItemProvider,	
-        IStructuredItemContentProvider,	
-        ITreeItemContentProvider,	
-        IItemLabelProvider,	
-        IItemPropertySource,
-        ITableItemLabelProvider{
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    @SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public LifecycleExtensionTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This returns LifecycleExtensionType.gif.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/LifecycleExtensionType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((LifecycleExtensionType) object).getTextContent();
-		return label == null || label.length() == 0 ? getString("_UI_LifecycleExtensionType_type")
-				: label;
-	}
-
-    /**
-	 * 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
-	 */
-    public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-		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
-	 */
-    protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		// TODO Auto-generated method stub
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_LifecycleExtensionType_type"); //$NON-NLS-1$
-		}
-		return null;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/LifecycleFactoryTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/LifecycleFactoryTypeItemProvider.java
deleted file mode 100644
index 58fbeca..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/LifecycleFactoryTypeItemProvider.java
+++ /dev/null
@@ -1,210 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.LifecycleFactoryType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleFactoryType} object.
- * <!-- begin-user-doc --> 
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class LifecycleFactoryTypeItemProvider extends ItemProviderAdapter
-		implements IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!--begin-user-doc --> 
-	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public LifecycleFactoryTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc --> 
- 	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_LifecycleFactoryType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_LifecycleFactoryType_textContent_feature", "_UI_LifecycleFactoryType_type"),
-				 FacesConfigPackage.Literals.LIFECYCLE_FACTORY_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc --> 
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_LifecycleFactoryType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_LifecycleFactoryType_id_feature", "_UI_LifecycleFactoryType_type"),
-				 FacesConfigPackage.Literals.LIFECYCLE_FACTORY_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns LifecycleFactoryType.gif.
-	 * <!-- begin-user-doc --> <!--
-	 * end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/LifecycleFactoryType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc
-	 * --> <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((LifecycleFactoryType) object).getTextContent();
-		return label == null || label.length() == 0 ? getString("_UI_LifecycleFactoryType_type")
-				: label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(LifecycleFactoryType.class)) {
-			case FacesConfigPackage.LIFECYCLE_FACTORY_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.LIFECYCLE_FACTORY_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-
-		switch (columnIndex) {
-
-			case 0:
-				return getText(object);
-			case 1:
-				return getString("_UI_LifecycleFactoryType_type"); //$NON-NLS-1$
-			}
-
-			return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/LifecycleTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/LifecycleTypeItemProvider.java
deleted file mode 100644
index 611aaf6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/LifecycleTypeItemProvider.java
+++ /dev/null
@@ -1,212 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.LifecycleType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class LifecycleTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public LifecycleTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_LifecycleType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_LifecycleType_id_feature", "_UI_LifecycleType_type"),
-				 FacesConfigPackage.Literals.LIFECYCLE_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.LIFECYCLE_TYPE__PHASE_LISTENER);
-			childrenFeatures.add(FacesConfigPackage.Literals.LIFECYCLE_TYPE__LIFECYCLE_EXTENSION);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    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 LifecycleType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/LifecycleType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((LifecycleType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_LifecycleType_type") :
-			getString("_UI_LifecycleType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(LifecycleType.class)) {
-			case FacesConfigPackage.LIFECYCLE_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.LIFECYCLE_TYPE__PHASE_LISTENER:
-			case FacesConfigPackage.LIFECYCLE_TYPE__LIFECYCLE_EXTENSION:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.LIFECYCLE_TYPE__PHASE_LISTENER,
-				 FacesConfigFactory.eINSTANCE.createPhaseListenerType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.LIFECYCLE_TYPE__LIFECYCLE_EXTENSION,
-				 FacesConfigFactory.eINSTANCE.createLifecycleExtensionType()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ListEntriesTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ListEntriesTypeItemProvider.java
deleted file mode 100644
index b7c6c79..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ListEntriesTypeItemProvider.java
+++ /dev/null
@@ -1,219 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ListEntriesTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ListEntriesTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ListEntriesType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ListEntriesType_id_feature", "_UI_ListEntriesType_type"),
-				 FacesConfigPackage.Literals.LIST_ENTRIES_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.LIST_ENTRIES_TYPE__VALUE_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.LIST_ENTRIES_TYPE__NULL_VALUE);
-			childrenFeatures.add(FacesConfigPackage.Literals.LIST_ENTRIES_TYPE__VALUE);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 ListEntriesType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ListEntriesType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((ListEntriesType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ListEntriesType_type") :
-			getString("_UI_ListEntriesType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ListEntriesType.class)) {
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__VALUE_CLASS:
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__NULL_VALUE:
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__VALUE:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.LIST_ENTRIES_TYPE__VALUE_CLASS,
-				 FacesConfigFactory.eINSTANCE.createValueClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.LIST_ENTRIES_TYPE__NULL_VALUE,
-				 FacesConfigFactory.eINSTANCE.createNullValueType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.LIST_ENTRIES_TYPE__VALUE,
-				 FacesConfigFactory.eINSTANCE.createValueType()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/Literals.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/Literals.java
deleted file mode 100644
index 678a586..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/Literals.java
+++ /dev/null
@@ -1,3595 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.provider;
-
-import org.eclipse.emf.ecore.EAttribute;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EReference;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * Literal package types
- * 
- * @author cbateman
- *
- */
-public interface Literals {
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ActionListenerTypeImpl <em>Action Listener Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ActionListenerTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getActionListenerType()
-	 * @generated
-	 */
-	EClass ACTION_LISTENER_TYPE = FacesConfigPackage.eINSTANCE.getActionListenerType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute ACTION_LISTENER_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getActionListenerType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute ACTION_LISTENER_TYPE__ID = FacesConfigPackage.eINSTANCE.getActionListenerType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationFactoryTypeImpl <em>Application Factory Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationFactoryTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getApplicationFactoryType()
-	 * @generated
-	 */
-	EClass APPLICATION_FACTORY_TYPE = FacesConfigPackage.eINSTANCE.getApplicationFactoryType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute APPLICATION_FACTORY_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getApplicationFactoryType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute APPLICATION_FACTORY_TYPE__ID = FacesConfigPackage.eINSTANCE.getApplicationFactoryType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl <em>Application Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getApplicationType()
-	 * @generated
-	 */
-	EClass APPLICATION_TYPE = FacesConfigPackage.eINSTANCE.getApplicationType();
-
-	/**
-	 * The meta object literal for the '<em><b>Action Listener</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference APPLICATION_TYPE__ACTION_LISTENER = FacesConfigPackage.eINSTANCE.getApplicationType_ActionListener();
-
-	/**
-	 * The meta object literal for the '<em><b>Default Render Kit Id</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference APPLICATION_TYPE__DEFAULT_RENDER_KIT_ID = FacesConfigPackage.eINSTANCE.getApplicationType_DefaultRenderKitId();
-
-	/**
-	 * The meta object literal for the '<em><b>Message Bundle</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference APPLICATION_TYPE__MESSAGE_BUNDLE = FacesConfigPackage.eINSTANCE.getApplicationType_MessageBundle();
-
-	/**
-	 * The meta object literal for the '<em><b>Navigation Handler</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference APPLICATION_TYPE__NAVIGATION_HANDLER = FacesConfigPackage.eINSTANCE.getApplicationType_NavigationHandler();
-
-	/**
-	 * The meta object literal for the '<em><b>View Handler</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference APPLICATION_TYPE__VIEW_HANDLER = FacesConfigPackage.eINSTANCE.getApplicationType_ViewHandler();
-
-	/**
-	 * The meta object literal for the '<em><b>State Manager</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference APPLICATION_TYPE__STATE_MANAGER = FacesConfigPackage.eINSTANCE.getApplicationType_StateManager();
-
-	/**
-	 * The meta object literal for the '<em><b>Property Resolver</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference APPLICATION_TYPE__PROPERTY_RESOLVER = FacesConfigPackage.eINSTANCE.getApplicationType_PropertyResolver();
-
-	/**
-	 * The meta object literal for the '<em><b>Variable Resolver</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference APPLICATION_TYPE__VARIABLE_RESOLVER = FacesConfigPackage.eINSTANCE.getApplicationType_VariableResolver();
-
-	/**
-	 * The meta object literal for the '<em><b>Locale Config</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference APPLICATION_TYPE__LOCALE_CONFIG = FacesConfigPackage.eINSTANCE.getApplicationType_LocaleConfig();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute APPLICATION_TYPE__ID = FacesConfigPackage.eINSTANCE.getApplicationType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeClassTypeImpl <em>Attribute Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getAttributeClassType()
-	 * @generated
-	 */
-	EClass ATTRIBUTE_CLASS_TYPE = FacesConfigPackage.eINSTANCE.getAttributeClassType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute ATTRIBUTE_CLASS_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getAttributeClassType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute ATTRIBUTE_CLASS_TYPE__ID = FacesConfigPackage.eINSTANCE.getAttributeClassType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeExtensionTypeImpl <em>Attribute Extension Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeExtensionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getAttributeExtensionType()
-	 * @generated
-	 */
-	EClass ATTRIBUTE_EXTENSION_TYPE = FacesConfigPackage.eINSTANCE.getAttributeExtensionType();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeNameTypeImpl <em>Attribute Name Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeNameTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getAttributeNameType()
-	 * @generated
-	 */
-	EClass ATTRIBUTE_NAME_TYPE = FacesConfigPackage.eINSTANCE.getAttributeNameType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute ATTRIBUTE_NAME_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getAttributeNameType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute ATTRIBUTE_NAME_TYPE__ID = FacesConfigPackage.eINSTANCE.getAttributeNameType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeTypeImpl <em>Attribute Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getAttributeType()
-	 * @generated
-	 */
-	EClass ATTRIBUTE_TYPE = FacesConfigPackage.eINSTANCE.getAttributeType();
-
-	/**
-	 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference ATTRIBUTE_TYPE__DESCRIPTION = FacesConfigPackage.eINSTANCE.getAttributeType_Description();
-
-	/**
-	 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference ATTRIBUTE_TYPE__DISPLAY_NAME = FacesConfigPackage.eINSTANCE.getAttributeType_DisplayName();
-
-	/**
-	 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference ATTRIBUTE_TYPE__ICON = FacesConfigPackage.eINSTANCE.getAttributeType_Icon();
-
-	/**
-	 * The meta object literal for the '<em><b>Attribute Name</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference ATTRIBUTE_TYPE__ATTRIBUTE_NAME = FacesConfigPackage.eINSTANCE.getAttributeType_AttributeName();
-
-	/**
-	 * The meta object literal for the '<em><b>Attribute Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference ATTRIBUTE_TYPE__ATTRIBUTE_CLASS = FacesConfigPackage.eINSTANCE.getAttributeType_AttributeClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Default Value</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference ATTRIBUTE_TYPE__DEFAULT_VALUE = FacesConfigPackage.eINSTANCE.getAttributeType_DefaultValue();
-
-	/**
-	 * The meta object literal for the '<em><b>Suggested Value</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference ATTRIBUTE_TYPE__SUGGESTED_VALUE = FacesConfigPackage.eINSTANCE.getAttributeType_SuggestedValue();
-
-	/**
-	 * The meta object literal for the '<em><b>Attribute Extension</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference ATTRIBUTE_TYPE__ATTRIBUTE_EXTENSION = FacesConfigPackage.eINSTANCE.getAttributeType_AttributeExtension();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute ATTRIBUTE_TYPE__ID = FacesConfigPackage.eINSTANCE.getAttributeType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentClassTypeImpl <em>Component Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getComponentClassType()
-	 * @generated
-	 */
-	EClass COMPONENT_CLASS_TYPE = FacesConfigPackage.eINSTANCE.getComponentClassType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute COMPONENT_CLASS_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getComponentClassType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute COMPONENT_CLASS_TYPE__ID = FacesConfigPackage.eINSTANCE.getComponentClassType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentExtensionTypeImpl <em>Component Extension Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentExtensionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getComponentExtensionType()
-	 * @generated
-	 */
-	EClass COMPONENT_EXTENSION_TYPE = FacesConfigPackage.eINSTANCE.getComponentExtensionType();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentFamilyTypeImpl <em>Component Family Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentFamilyTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getComponentFamilyType()
-	 * @generated
-	 */
-	EClass COMPONENT_FAMILY_TYPE = FacesConfigPackage.eINSTANCE.getComponentFamilyType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute COMPONENT_FAMILY_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getComponentFamilyType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute COMPONENT_FAMILY_TYPE__ID = FacesConfigPackage.eINSTANCE.getComponentFamilyType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeImpl <em>Component Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getComponentType()
-	 * @generated
-	 */
-	EClass COMPONENT_TYPE = FacesConfigPackage.eINSTANCE.getComponentType();
-
-	/**
-	 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference COMPONENT_TYPE__DESCRIPTION = FacesConfigPackage.eINSTANCE.getComponentType_Description();
-
-	/**
-	 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference COMPONENT_TYPE__DISPLAY_NAME = FacesConfigPackage.eINSTANCE.getComponentType_DisplayName();
-
-	/**
-	 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference COMPONENT_TYPE__ICON = FacesConfigPackage.eINSTANCE.getComponentType_Icon();
-
-	/**
-	 * The meta object literal for the '<em><b>Component Type</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference COMPONENT_TYPE__COMPONENT_TYPE = FacesConfigPackage.eINSTANCE.getComponentType_ComponentType();
-
-	/**
-	 * The meta object literal for the '<em><b>Component Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference COMPONENT_TYPE__COMPONENT_CLASS = FacesConfigPackage.eINSTANCE.getComponentType_ComponentClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Facet</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference COMPONENT_TYPE__FACET = FacesConfigPackage.eINSTANCE.getComponentType_Facet();
-
-	/**
-	 * The meta object literal for the '<em><b>Attribute</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference COMPONENT_TYPE__ATTRIBUTE = FacesConfigPackage.eINSTANCE.getComponentType_Attribute();
-
-	/**
-	 * The meta object literal for the '<em><b>Property</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference COMPONENT_TYPE__PROPERTY = FacesConfigPackage.eINSTANCE.getComponentType_Property();
-
-	/**
-	 * The meta object literal for the '<em><b>Component Extension</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference COMPONENT_TYPE__COMPONENT_EXTENSION = FacesConfigPackage.eINSTANCE.getComponentType_ComponentExtension();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute COMPONENT_TYPE__ID = FacesConfigPackage.eINSTANCE.getComponentType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeTypeImpl <em>Component Type Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getComponentTypeType()
-	 * @generated
-	 */
-	EClass COMPONENT_TYPE_TYPE = FacesConfigPackage.eINSTANCE.getComponentTypeType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute COMPONENT_TYPE_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getComponentTypeType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute COMPONENT_TYPE_TYPE__ID = FacesConfigPackage.eINSTANCE.getComponentTypeType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterClassTypeImpl <em>Converter Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getConverterClassType()
-	 * @generated
-	 */
-	EClass CONVERTER_CLASS_TYPE = FacesConfigPackage.eINSTANCE.getConverterClassType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute CONVERTER_CLASS_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getConverterClassType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute CONVERTER_CLASS_TYPE__ID = FacesConfigPackage.eINSTANCE.getConverterClassType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterForClassTypeImpl <em>Converter For Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterForClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getConverterForClassType()
-	 * @generated
-	 */
-	EClass CONVERTER_FOR_CLASS_TYPE = FacesConfigPackage.eINSTANCE.getConverterForClassType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute CONVERTER_FOR_CLASS_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getConverterForClassType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute CONVERTER_FOR_CLASS_TYPE__ID = FacesConfigPackage.eINSTANCE.getConverterForClassType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterIdTypeImpl <em>Converter Id Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterIdTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getConverterIdType()
-	 * @generated
-	 */
-	EClass CONVERTER_ID_TYPE = FacesConfigPackage.eINSTANCE.getConverterIdType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute CONVERTER_ID_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getConverterIdType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute CONVERTER_ID_TYPE__ID = FacesConfigPackage.eINSTANCE.getConverterIdType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterTypeImpl <em>Converter Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getConverterType()
-	 * @generated
-	 */
-	EClass CONVERTER_TYPE = FacesConfigPackage.eINSTANCE.getConverterType();
-
-	/**
-	 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference CONVERTER_TYPE__DESCRIPTION = FacesConfigPackage.eINSTANCE.getConverterType_Description();
-
-	/**
-	 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference CONVERTER_TYPE__DISPLAY_NAME = FacesConfigPackage.eINSTANCE.getConverterType_DisplayName();
-
-	/**
-	 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference CONVERTER_TYPE__ICON = FacesConfigPackage.eINSTANCE.getConverterType_Icon();
-
-	/**
-	 * The meta object literal for the '<em><b>Converter Id</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference CONVERTER_TYPE__CONVERTER_ID = FacesConfigPackage.eINSTANCE.getConverterType_ConverterId();
-
-	/**
-	 * The meta object literal for the '<em><b>Converter For Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference CONVERTER_TYPE__CONVERTER_FOR_CLASS = FacesConfigPackage.eINSTANCE.getConverterType_ConverterForClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Converter Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference CONVERTER_TYPE__CONVERTER_CLASS = FacesConfigPackage.eINSTANCE.getConverterType_ConverterClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Attribute</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference CONVERTER_TYPE__ATTRIBUTE = FacesConfigPackage.eINSTANCE.getConverterType_Attribute();
-
-	/**
-	 * The meta object literal for the '<em><b>Property</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference CONVERTER_TYPE__PROPERTY = FacesConfigPackage.eINSTANCE.getConverterType_Property();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute CONVERTER_TYPE__ID = FacesConfigPackage.eINSTANCE.getConverterType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultLocaleTypeImpl <em>Default Locale Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultLocaleTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDefaultLocaleType()
-	 * @generated
-	 */
-	EClass DEFAULT_LOCALE_TYPE = FacesConfigPackage.eINSTANCE.getDefaultLocaleType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute DEFAULT_LOCALE_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getDefaultLocaleType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute DEFAULT_LOCALE_TYPE__ID = FacesConfigPackage.eINSTANCE.getDefaultLocaleType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultRenderKitIdTypeImpl <em>Default Render Kit Id Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultRenderKitIdTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDefaultRenderKitIdType()
-	 * @generated
-	 */
-	EClass DEFAULT_RENDER_KIT_ID_TYPE = FacesConfigPackage.eINSTANCE.getDefaultRenderKitIdType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute DEFAULT_RENDER_KIT_ID_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getDefaultRenderKitIdType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute DEFAULT_RENDER_KIT_ID_TYPE__ID = FacesConfigPackage.eINSTANCE.getDefaultRenderKitIdType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultValueTypeImpl <em>Default Value Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultValueTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDefaultValueType()
-	 * @generated
-	 */
-	EClass DEFAULT_VALUE_TYPE = FacesConfigPackage.eINSTANCE.getDefaultValueType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute DEFAULT_VALUE_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getDefaultValueType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute DEFAULT_VALUE_TYPE__ID = FacesConfigPackage.eINSTANCE.getDefaultValueType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DescriptionTypeImpl <em>Description Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DescriptionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDescriptionType()
-	 * @generated
-	 */
-	EClass DESCRIPTION_TYPE = FacesConfigPackage.eINSTANCE.getDescriptionType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute DESCRIPTION_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getDescriptionType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Lang</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute DESCRIPTION_TYPE__LANG = FacesConfigPackage.eINSTANCE.getDescriptionType_Lang();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute DESCRIPTION_TYPE__ID = FacesConfigPackage.eINSTANCE.getDescriptionType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DisplayNameTypeImpl <em>Display Name Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DisplayNameTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDisplayNameType()
-	 * @generated
-	 */
-	EClass DISPLAY_NAME_TYPE = FacesConfigPackage.eINSTANCE.getDisplayNameType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute DISPLAY_NAME_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getDisplayNameType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Lang</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute DISPLAY_NAME_TYPE__LANG = FacesConfigPackage.eINSTANCE.getDisplayNameType_Lang();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute DISPLAY_NAME_TYPE__ID = FacesConfigPackage.eINSTANCE.getDisplayNameType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl <em>Document Root</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDocumentRoot()
-	 * @generated
-	 */
-	EClass DOCUMENT_ROOT = FacesConfigPackage.eINSTANCE.getDocumentRoot();
-
-	/**
-	 * The meta object literal for the '<em><b>Mixed</b></em>' attribute list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute DOCUMENT_ROOT__MIXED = FacesConfigPackage.eINSTANCE.getDocumentRoot_Mixed();
-
-	/**
-	 * The meta object literal for the '<em><b>XMLNS Prefix Map</b></em>' map feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__XMLNS_PREFIX_MAP = FacesConfigPackage.eINSTANCE.getDocumentRoot_XMLNSPrefixMap();
-
-	/**
-	 * The meta object literal for the '<em><b>XSI Schema Location</b></em>' map feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__XSI_SCHEMA_LOCATION = FacesConfigPackage.eINSTANCE.getDocumentRoot_XSISchemaLocation();
-
-	/**
-	 * The meta object literal for the '<em><b>Action Listener</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__ACTION_LISTENER = FacesConfigPackage.eINSTANCE.getDocumentRoot_ActionListener();
-
-	/**
-	 * The meta object literal for the '<em><b>Application</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__APPLICATION = FacesConfigPackage.eINSTANCE.getDocumentRoot_Application();
-
-	/**
-	 * The meta object literal for the '<em><b>Application Factory</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__APPLICATION_FACTORY = FacesConfigPackage.eINSTANCE.getDocumentRoot_ApplicationFactory();
-
-	/**
-	 * The meta object literal for the '<em><b>Attribute</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__ATTRIBUTE = FacesConfigPackage.eINSTANCE.getDocumentRoot_Attribute();
-
-	/**
-	 * The meta object literal for the '<em><b>Attribute Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__ATTRIBUTE_CLASS = FacesConfigPackage.eINSTANCE.getDocumentRoot_AttributeClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Attribute Extension</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__ATTRIBUTE_EXTENSION = FacesConfigPackage.eINSTANCE.getDocumentRoot_AttributeExtension();
-
-	/**
-	 * The meta object literal for the '<em><b>Attribute Name</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__ATTRIBUTE_NAME = FacesConfigPackage.eINSTANCE.getDocumentRoot_AttributeName();
-
-	/**
-	 * The meta object literal for the '<em><b>Component</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__COMPONENT = FacesConfigPackage.eINSTANCE.getDocumentRoot_Component();
-
-	/**
-	 * The meta object literal for the '<em><b>Component Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__COMPONENT_CLASS = FacesConfigPackage.eINSTANCE.getDocumentRoot_ComponentClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Component Extension</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__COMPONENT_EXTENSION = FacesConfigPackage.eINSTANCE.getDocumentRoot_ComponentExtension();
-
-	/**
-	 * The meta object literal for the '<em><b>Component Family</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__COMPONENT_FAMILY = FacesConfigPackage.eINSTANCE.getDocumentRoot_ComponentFamily();
-
-	/**
-	 * The meta object literal for the '<em><b>Component Type</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__COMPONENT_TYPE = FacesConfigPackage.eINSTANCE.getDocumentRoot_ComponentType();
-
-	/**
-	 * The meta object literal for the '<em><b>Converter</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__CONVERTER = FacesConfigPackage.eINSTANCE.getDocumentRoot_Converter();
-
-	/**
-	 * The meta object literal for the '<em><b>Converter Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__CONVERTER_CLASS = FacesConfigPackage.eINSTANCE.getDocumentRoot_ConverterClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Converter For Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__CONVERTER_FOR_CLASS = FacesConfigPackage.eINSTANCE.getDocumentRoot_ConverterForClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Converter Id</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__CONVERTER_ID = FacesConfigPackage.eINSTANCE.getDocumentRoot_ConverterId();
-
-	/**
-	 * The meta object literal for the '<em><b>Default Locale</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__DEFAULT_LOCALE = FacesConfigPackage.eINSTANCE.getDocumentRoot_DefaultLocale();
-
-	/**
-	 * The meta object literal for the '<em><b>Default Render Kit Id</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__DEFAULT_RENDER_KIT_ID = FacesConfigPackage.eINSTANCE.getDocumentRoot_DefaultRenderKitId();
-
-	/**
-	 * The meta object literal for the '<em><b>Default Value</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__DEFAULT_VALUE = FacesConfigPackage.eINSTANCE.getDocumentRoot_DefaultValue();
-
-	/**
-	 * The meta object literal for the '<em><b>Description</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__DESCRIPTION = FacesConfigPackage.eINSTANCE.getDocumentRoot_Description();
-
-	/**
-	 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__DISPLAY_NAME = FacesConfigPackage.eINSTANCE.getDocumentRoot_DisplayName();
-
-	/**
-	 * The meta object literal for the '<em><b>Faces Config</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__FACES_CONFIG = FacesConfigPackage.eINSTANCE.getDocumentRoot_FacesConfig();
-
-	/**
-	 * The meta object literal for the '<em><b>Faces Context Factory</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__FACES_CONTEXT_FACTORY = FacesConfigPackage.eINSTANCE.getDocumentRoot_FacesContextFactory();
-
-	/**
-	 * The meta object literal for the '<em><b>Facet</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__FACET = FacesConfigPackage.eINSTANCE.getDocumentRoot_Facet();
-
-	/**
-	 * The meta object literal for the '<em><b>Facet Extension</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__FACET_EXTENSION = FacesConfigPackage.eINSTANCE.getDocumentRoot_FacetExtension();
-
-	/**
-	 * The meta object literal for the '<em><b>Facet Name</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__FACET_NAME = FacesConfigPackage.eINSTANCE.getDocumentRoot_FacetName();
-
-	/**
-	 * The meta object literal for the '<em><b>Factory</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__FACTORY = FacesConfigPackage.eINSTANCE.getDocumentRoot_Factory();
-
-	/**
-	 * The meta object literal for the '<em><b>From Action</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__FROM_ACTION = FacesConfigPackage.eINSTANCE.getDocumentRoot_FromAction();
-
-	/**
-	 * The meta object literal for the '<em><b>From Outcome</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__FROM_OUTCOME = FacesConfigPackage.eINSTANCE.getDocumentRoot_FromOutcome();
-
-	/**
-	 * The meta object literal for the '<em><b>From View Id</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__FROM_VIEW_ID = FacesConfigPackage.eINSTANCE.getDocumentRoot_FromViewId();
-
-	/**
-	 * The meta object literal for the '<em><b>Icon</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__ICON = FacesConfigPackage.eINSTANCE.getDocumentRoot_Icon();
-
-	/**
-	 * The meta object literal for the '<em><b>Key</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__KEY = FacesConfigPackage.eINSTANCE.getDocumentRoot_Key();
-
-	/**
-	 * The meta object literal for the '<em><b>Key Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__KEY_CLASS = FacesConfigPackage.eINSTANCE.getDocumentRoot_KeyClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Large Icon</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__LARGE_ICON = FacesConfigPackage.eINSTANCE.getDocumentRoot_LargeIcon();
-
-	/**
-	 * The meta object literal for the '<em><b>Lifecycle</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__LIFECYCLE = FacesConfigPackage.eINSTANCE.getDocumentRoot_Lifecycle();
-
-	/**
-	 * The meta object literal for the '<em><b>Lifecycle Factory</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__LIFECYCLE_FACTORY = FacesConfigPackage.eINSTANCE.getDocumentRoot_LifecycleFactory();
-
-	/**
-	 * The meta object literal for the '<em><b>List Entries</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__LIST_ENTRIES = FacesConfigPackage.eINSTANCE.getDocumentRoot_ListEntries();
-
-	/**
-	 * The meta object literal for the '<em><b>Locale Config</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__LOCALE_CONFIG = FacesConfigPackage.eINSTANCE.getDocumentRoot_LocaleConfig();
-
-	/**
-	 * The meta object literal for the '<em><b>Managed Bean</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__MANAGED_BEAN = FacesConfigPackage.eINSTANCE.getDocumentRoot_ManagedBean();
-
-	/**
-	 * The meta object literal for the '<em><b>Managed Bean Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__MANAGED_BEAN_CLASS = FacesConfigPackage.eINSTANCE.getDocumentRoot_ManagedBeanClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Managed Bean Name</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__MANAGED_BEAN_NAME = FacesConfigPackage.eINSTANCE.getDocumentRoot_ManagedBeanName();
-
-	/**
-	 * The meta object literal for the '<em><b>Managed Bean Scope</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__MANAGED_BEAN_SCOPE = FacesConfigPackage.eINSTANCE.getDocumentRoot_ManagedBeanScope();
-
-	/**
-	 * The meta object literal for the '<em><b>Managed Property</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__MANAGED_PROPERTY = FacesConfigPackage.eINSTANCE.getDocumentRoot_ManagedProperty();
-
-	/**
-	 * The meta object literal for the '<em><b>Map Entries</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__MAP_ENTRIES = FacesConfigPackage.eINSTANCE.getDocumentRoot_MapEntries();
-
-	/**
-	 * The meta object literal for the '<em><b>Map Entry</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__MAP_ENTRY = FacesConfigPackage.eINSTANCE.getDocumentRoot_MapEntry();
-
-	/**
-	 * The meta object literal for the '<em><b>Message Bundle</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__MESSAGE_BUNDLE = FacesConfigPackage.eINSTANCE.getDocumentRoot_MessageBundle();
-
-	/**
-	 * The meta object literal for the '<em><b>Navigation Case</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__NAVIGATION_CASE = FacesConfigPackage.eINSTANCE.getDocumentRoot_NavigationCase();
-
-	/**
-	 * The meta object literal for the '<em><b>Navigation Handler</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__NAVIGATION_HANDLER = FacesConfigPackage.eINSTANCE.getDocumentRoot_NavigationHandler();
-
-	/**
-	 * The meta object literal for the '<em><b>Navigation Rule</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__NAVIGATION_RULE = FacesConfigPackage.eINSTANCE.getDocumentRoot_NavigationRule();
-
-	/**
-	 * The meta object literal for the '<em><b>Null Value</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__NULL_VALUE = FacesConfigPackage.eINSTANCE.getDocumentRoot_NullValue();
-
-	/**
-	 * The meta object literal for the '<em><b>Phase Listener</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__PHASE_LISTENER = FacesConfigPackage.eINSTANCE.getDocumentRoot_PhaseListener();
-
-	/**
-	 * The meta object literal for the '<em><b>Property</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__PROPERTY = FacesConfigPackage.eINSTANCE.getDocumentRoot_Property();
-
-	/**
-	 * The meta object literal for the '<em><b>Property Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__PROPERTY_CLASS = FacesConfigPackage.eINSTANCE.getDocumentRoot_PropertyClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Property Extension</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__PROPERTY_EXTENSION = FacesConfigPackage.eINSTANCE.getDocumentRoot_PropertyExtension();
-
-	/**
-	 * The meta object literal for the '<em><b>Property Name</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__PROPERTY_NAME = FacesConfigPackage.eINSTANCE.getDocumentRoot_PropertyName();
-
-	/**
-	 * The meta object literal for the '<em><b>Property Resolver</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__PROPERTY_RESOLVER = FacesConfigPackage.eINSTANCE.getDocumentRoot_PropertyResolver();
-
-	/**
-	 * The meta object literal for the '<em><b>Redirect</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__REDIRECT = FacesConfigPackage.eINSTANCE.getDocumentRoot_Redirect();
-
-	/**
-	 * The meta object literal for the '<em><b>Referenced Bean</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__REFERENCED_BEAN = FacesConfigPackage.eINSTANCE.getDocumentRoot_ReferencedBean();
-
-	/**
-	 * The meta object literal for the '<em><b>Referenced Bean Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__REFERENCED_BEAN_CLASS = FacesConfigPackage.eINSTANCE.getDocumentRoot_ReferencedBeanClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Referenced Bean Name</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__REFERENCED_BEAN_NAME = FacesConfigPackage.eINSTANCE.getDocumentRoot_ReferencedBeanName();
-
-	/**
-	 * The meta object literal for the '<em><b>Renderer</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__RENDERER = FacesConfigPackage.eINSTANCE.getDocumentRoot_Renderer();
-
-	/**
-	 * The meta object literal for the '<em><b>Renderer Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__RENDERER_CLASS = FacesConfigPackage.eINSTANCE.getDocumentRoot_RendererClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Renderer Extension</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__RENDERER_EXTENSION = FacesConfigPackage.eINSTANCE.getDocumentRoot_RendererExtension();
-
-	/**
-	 * The meta object literal for the '<em><b>Renderer Type</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__RENDERER_TYPE = FacesConfigPackage.eINSTANCE.getDocumentRoot_RendererType();
-
-	/**
-	 * The meta object literal for the '<em><b>Render Kit</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__RENDER_KIT = FacesConfigPackage.eINSTANCE.getDocumentRoot_RenderKit();
-
-	/**
-	 * The meta object literal for the '<em><b>Render Kit Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__RENDER_KIT_CLASS = FacesConfigPackage.eINSTANCE.getDocumentRoot_RenderKitClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Render Kit Factory</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__RENDER_KIT_FACTORY = FacesConfigPackage.eINSTANCE.getDocumentRoot_RenderKitFactory();
-
-	/**
-	 * The meta object literal for the '<em><b>Render Kit Id</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__RENDER_KIT_ID = FacesConfigPackage.eINSTANCE.getDocumentRoot_RenderKitId();
-
-	/**
-	 * The meta object literal for the '<em><b>Small Icon</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__SMALL_ICON = FacesConfigPackage.eINSTANCE.getDocumentRoot_SmallIcon();
-
-	/**
-	 * The meta object literal for the '<em><b>State Manager</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__STATE_MANAGER = FacesConfigPackage.eINSTANCE.getDocumentRoot_StateManager();
-
-	/**
-	 * The meta object literal for the '<em><b>Suggested Value</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__SUGGESTED_VALUE = FacesConfigPackage.eINSTANCE.getDocumentRoot_SuggestedValue();
-
-	/**
-	 * The meta object literal for the '<em><b>Supported Locale</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__SUPPORTED_LOCALE = FacesConfigPackage.eINSTANCE.getDocumentRoot_SupportedLocale();
-
-	/**
-	 * The meta object literal for the '<em><b>To View Id</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__TO_VIEW_ID = FacesConfigPackage.eINSTANCE.getDocumentRoot_ToViewId();
-
-	/**
-	 * The meta object literal for the '<em><b>Validator</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__VALIDATOR = FacesConfigPackage.eINSTANCE.getDocumentRoot_Validator();
-
-	/**
-	 * The meta object literal for the '<em><b>Validator Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__VALIDATOR_CLASS = FacesConfigPackage.eINSTANCE.getDocumentRoot_ValidatorClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Validator Id</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__VALIDATOR_ID = FacesConfigPackage.eINSTANCE.getDocumentRoot_ValidatorId();
-
-	/**
-	 * The meta object literal for the '<em><b>Value</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__VALUE = FacesConfigPackage.eINSTANCE.getDocumentRoot_Value();
-
-	/**
-	 * The meta object literal for the '<em><b>Value Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__VALUE_CLASS = FacesConfigPackage.eINSTANCE.getDocumentRoot_ValueClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Variable Resolver</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__VARIABLE_RESOLVER = FacesConfigPackage.eINSTANCE.getDocumentRoot_VariableResolver();
-
-	/**
-	 * The meta object literal for the '<em><b>View Handler</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference DOCUMENT_ROOT__VIEW_HANDLER = FacesConfigPackage.eINSTANCE.getDocumentRoot_ViewHandler();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl <em>Faces Config Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFacesConfigType()
-	 * @generated
-	 */
-	EClass FACES_CONFIG_TYPE = FacesConfigPackage.eINSTANCE.getFacesConfigType();
-
-	/**
-	 * The meta object literal for the '<em><b>Application</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference FACES_CONFIG_TYPE__APPLICATION = FacesConfigPackage.eINSTANCE.getFacesConfigType_Application();
-
-	/**
-	 * The meta object literal for the '<em><b>Factory</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference FACES_CONFIG_TYPE__FACTORY = FacesConfigPackage.eINSTANCE.getFacesConfigType_Factory();
-
-	/**
-	 * The meta object literal for the '<em><b>Component</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference FACES_CONFIG_TYPE__COMPONENT = FacesConfigPackage.eINSTANCE.getFacesConfigType_Component();
-
-	/**
-	 * The meta object literal for the '<em><b>Converter</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference FACES_CONFIG_TYPE__CONVERTER = FacesConfigPackage.eINSTANCE.getFacesConfigType_Converter();
-
-	/**
-	 * The meta object literal for the '<em><b>Managed Bean</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference FACES_CONFIG_TYPE__MANAGED_BEAN = FacesConfigPackage.eINSTANCE.getFacesConfigType_ManagedBean();
-
-	/**
-	 * The meta object literal for the '<em><b>Navigation Rule</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference FACES_CONFIG_TYPE__NAVIGATION_RULE = FacesConfigPackage.eINSTANCE.getFacesConfigType_NavigationRule();
-
-	/**
-	 * The meta object literal for the '<em><b>Referenced Bean</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference FACES_CONFIG_TYPE__REFERENCED_BEAN = FacesConfigPackage.eINSTANCE.getFacesConfigType_ReferencedBean();
-
-	/**
-	 * The meta object literal for the '<em><b>Render Kit</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference FACES_CONFIG_TYPE__RENDER_KIT = FacesConfigPackage.eINSTANCE.getFacesConfigType_RenderKit();
-
-	/**
-	 * The meta object literal for the '<em><b>Lifecycle</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference FACES_CONFIG_TYPE__LIFECYCLE = FacesConfigPackage.eINSTANCE.getFacesConfigType_Lifecycle();
-
-	/**
-	 * The meta object literal for the '<em><b>Validator</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference FACES_CONFIG_TYPE__VALIDATOR = FacesConfigPackage.eINSTANCE.getFacesConfigType_Validator();
-
-	/**
-	 * The meta object literal for the '<em><b>Xmlns</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute FACES_CONFIG_TYPE__XMLNS = FacesConfigPackage.eINSTANCE.getFacesConfigType_Xmlns();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute FACES_CONFIG_TYPE__ID = FacesConfigPackage.eINSTANCE.getFacesConfigType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesContextFactoryTypeImpl <em>Faces Context Factory Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesContextFactoryTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFacesContextFactoryType()
-	 * @generated
-	 */
-	EClass FACES_CONTEXT_FACTORY_TYPE = FacesConfigPackage.eINSTANCE.getFacesContextFactoryType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute FACES_CONTEXT_FACTORY_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getFacesContextFactoryType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute FACES_CONTEXT_FACTORY_TYPE__ID = FacesConfigPackage.eINSTANCE.getFacesContextFactoryType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacetExtensionTypeImpl <em>Facet Extension Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacetExtensionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFacetExtensionType()
-	 * @generated
-	 */
-	EClass FACET_EXTENSION_TYPE = FacesConfigPackage.eINSTANCE.getFacetExtensionType();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacetNameTypeImpl <em>Facet Name Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacetNameTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFacetNameType()
-	 * @generated
-	 */
-	EClass FACET_NAME_TYPE = FacesConfigPackage.eINSTANCE.getFacetNameType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute FACET_NAME_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getFacetNameType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute FACET_NAME_TYPE__ID = FacesConfigPackage.eINSTANCE.getFacetNameType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacetTypeImpl <em>Facet Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacetTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFacetType()
-	 * @generated
-	 */
-	EClass FACET_TYPE = FacesConfigPackage.eINSTANCE.getFacetType();
-
-	/**
-	 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference FACET_TYPE__DESCRIPTION = FacesConfigPackage.eINSTANCE.getFacetType_Description();
-
-	/**
-	 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference FACET_TYPE__DISPLAY_NAME = FacesConfigPackage.eINSTANCE.getFacetType_DisplayName();
-
-	/**
-	 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference FACET_TYPE__ICON = FacesConfigPackage.eINSTANCE.getFacetType_Icon();
-
-	/**
-	 * The meta object literal for the '<em><b>Facet Name</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference FACET_TYPE__FACET_NAME = FacesConfigPackage.eINSTANCE.getFacetType_FacetName();
-
-	/**
-	 * The meta object literal for the '<em><b>Facet Extension</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference FACET_TYPE__FACET_EXTENSION = FacesConfigPackage.eINSTANCE.getFacetType_FacetExtension();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute FACET_TYPE__ID = FacesConfigPackage.eINSTANCE.getFacetType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryTypeImpl <em>Factory Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFactoryType()
-	 * @generated
-	 */
-	EClass FACTORY_TYPE = FacesConfigPackage.eINSTANCE.getFactoryType();
-
-	/**
-	 * The meta object literal for the '<em><b>Application Factory</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference FACTORY_TYPE__APPLICATION_FACTORY = FacesConfigPackage.eINSTANCE.getFactoryType_ApplicationFactory();
-
-	/**
-	 * The meta object literal for the '<em><b>Faces Context Factory</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference FACTORY_TYPE__FACES_CONTEXT_FACTORY = FacesConfigPackage.eINSTANCE.getFactoryType_FacesContextFactory();
-
-	/**
-	 * The meta object literal for the '<em><b>Lifecycle Factory</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference FACTORY_TYPE__LIFECYCLE_FACTORY = FacesConfigPackage.eINSTANCE.getFactoryType_LifecycleFactory();
-
-	/**
-	 * The meta object literal for the '<em><b>Render Kit Factory</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference FACTORY_TYPE__RENDER_KIT_FACTORY = FacesConfigPackage.eINSTANCE.getFactoryType_RenderKitFactory();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute FACTORY_TYPE__ID = FacesConfigPackage.eINSTANCE.getFactoryType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FromActionTypeImpl <em>From Action Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FromActionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFromActionType()
-	 * @generated
-	 */
-	EClass FROM_ACTION_TYPE = FacesConfigPackage.eINSTANCE.getFromActionType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute FROM_ACTION_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getFromActionType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute FROM_ACTION_TYPE__ID = FacesConfigPackage.eINSTANCE.getFromActionType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FromOutcomeTypeImpl <em>From Outcome Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FromOutcomeTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFromOutcomeType()
-	 * @generated
-	 */
-	EClass FROM_OUTCOME_TYPE = FacesConfigPackage.eINSTANCE.getFromOutcomeType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute FROM_OUTCOME_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getFromOutcomeType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute FROM_OUTCOME_TYPE__ID = FacesConfigPackage.eINSTANCE.getFromOutcomeType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FromViewIdTypeImpl <em>From View Id Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FromViewIdTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFromViewIdType()
-	 * @generated
-	 */
-	EClass FROM_VIEW_ID_TYPE = FacesConfigPackage.eINSTANCE.getFromViewIdType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute FROM_VIEW_ID_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getFromViewIdType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute FROM_VIEW_ID_TYPE__ID = FacesConfigPackage.eINSTANCE.getFromViewIdType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.IconTypeImpl <em>Icon Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.IconTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getIconType()
-	 * @generated
-	 */
-	EClass ICON_TYPE = FacesConfigPackage.eINSTANCE.getIconType();
-
-	/**
-	 * The meta object literal for the '<em><b>Small Icon</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference ICON_TYPE__SMALL_ICON = FacesConfigPackage.eINSTANCE.getIconType_SmallIcon();
-
-	/**
-	 * The meta object literal for the '<em><b>Large Icon</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference ICON_TYPE__LARGE_ICON = FacesConfigPackage.eINSTANCE.getIconType_LargeIcon();
-
-	/**
-	 * The meta object literal for the '<em><b>Lang</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute ICON_TYPE__LANG = FacesConfigPackage.eINSTANCE.getIconType_Lang();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute ICON_TYPE__ID = FacesConfigPackage.eINSTANCE.getIconType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.KeyClassTypeImpl <em>Key Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.KeyClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getKeyClassType()
-	 * @generated
-	 */
-	EClass KEY_CLASS_TYPE = FacesConfigPackage.eINSTANCE.getKeyClassType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute KEY_CLASS_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getKeyClassType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute KEY_CLASS_TYPE__ID = FacesConfigPackage.eINSTANCE.getKeyClassType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.KeyTypeImpl <em>Key Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.KeyTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getKeyType()
-	 * @generated
-	 */
-	EClass KEY_TYPE = FacesConfigPackage.eINSTANCE.getKeyType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute KEY_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getKeyType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute KEY_TYPE__ID = FacesConfigPackage.eINSTANCE.getKeyType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LargeIconTypeImpl <em>Large Icon Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.LargeIconTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getLargeIconType()
-	 * @generated
-	 */
-	EClass LARGE_ICON_TYPE = FacesConfigPackage.eINSTANCE.getLargeIconType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute LARGE_ICON_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getLargeIconType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute LARGE_ICON_TYPE__ID = FacesConfigPackage.eINSTANCE.getLargeIconType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LifecycleFactoryTypeImpl <em>Lifecycle Factory Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.LifecycleFactoryTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getLifecycleFactoryType()
-	 * @generated
-	 */
-	EClass LIFECYCLE_FACTORY_TYPE = FacesConfigPackage.eINSTANCE.getLifecycleFactoryType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute LIFECYCLE_FACTORY_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getLifecycleFactoryType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute LIFECYCLE_FACTORY_TYPE__ID = FacesConfigPackage.eINSTANCE.getLifecycleFactoryType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LifecycleTypeImpl <em>Lifecycle Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.LifecycleTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getLifecycleType()
-	 * @generated
-	 */
-	EClass LIFECYCLE_TYPE = FacesConfigPackage.eINSTANCE.getLifecycleType();
-
-	/**
-	 * The meta object literal for the '<em><b>Phase Listener</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference LIFECYCLE_TYPE__PHASE_LISTENER = FacesConfigPackage.eINSTANCE.getLifecycleType_PhaseListener();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute LIFECYCLE_TYPE__ID = FacesConfigPackage.eINSTANCE.getLifecycleType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ListEntriesTypeImpl <em>List Entries Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ListEntriesTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getListEntriesType()
-	 * @generated
-	 */
-	EClass LIST_ENTRIES_TYPE = FacesConfigPackage.eINSTANCE.getListEntriesType();
-
-	/**
-	 * The meta object literal for the '<em><b>Value Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference LIST_ENTRIES_TYPE__VALUE_CLASS = FacesConfigPackage.eINSTANCE.getListEntriesType_ValueClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Null Value</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference LIST_ENTRIES_TYPE__NULL_VALUE = FacesConfigPackage.eINSTANCE.getListEntriesType_NullValue();
-
-	/**
-	 * The meta object literal for the '<em><b>Value</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference LIST_ENTRIES_TYPE__VALUE = FacesConfigPackage.eINSTANCE.getListEntriesType_Value();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute LIST_ENTRIES_TYPE__ID = FacesConfigPackage.eINSTANCE.getListEntriesType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LocaleConfigTypeImpl <em>Locale Config Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.LocaleConfigTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getLocaleConfigType()
-	 * @generated
-	 */
-	EClass LOCALE_CONFIG_TYPE = FacesConfigPackage.eINSTANCE.getLocaleConfigType();
-
-	/**
-	 * The meta object literal for the '<em><b>Default Locale</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference LOCALE_CONFIG_TYPE__DEFAULT_LOCALE = FacesConfigPackage.eINSTANCE.getLocaleConfigType_DefaultLocale();
-
-	/**
-	 * The meta object literal for the '<em><b>Supported Locale</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference LOCALE_CONFIG_TYPE__SUPPORTED_LOCALE = FacesConfigPackage.eINSTANCE.getLocaleConfigType_SupportedLocale();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute LOCALE_CONFIG_TYPE__ID = FacesConfigPackage.eINSTANCE.getLocaleConfigType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanClassTypeImpl <em>Managed Bean Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getManagedBeanClassType()
-	 * @generated
-	 */
-	EClass MANAGED_BEAN_CLASS_TYPE = FacesConfigPackage.eINSTANCE.getManagedBeanClassType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute MANAGED_BEAN_CLASS_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getManagedBeanClassType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute MANAGED_BEAN_CLASS_TYPE__ID = FacesConfigPackage.eINSTANCE.getManagedBeanClassType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanNameTypeImpl <em>Managed Bean Name Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanNameTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getManagedBeanNameType()
-	 * @generated
-	 */
-	EClass MANAGED_BEAN_NAME_TYPE = FacesConfigPackage.eINSTANCE.getManagedBeanNameType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute MANAGED_BEAN_NAME_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getManagedBeanNameType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute MANAGED_BEAN_NAME_TYPE__ID = FacesConfigPackage.eINSTANCE.getManagedBeanNameType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanScopeTypeImpl <em>Managed Bean Scope Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanScopeTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getManagedBeanScopeType()
-	 * @generated
-	 */
-	EClass MANAGED_BEAN_SCOPE_TYPE = FacesConfigPackage.eINSTANCE.getManagedBeanScopeType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute MANAGED_BEAN_SCOPE_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getManagedBeanScopeType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute MANAGED_BEAN_SCOPE_TYPE__ID = FacesConfigPackage.eINSTANCE.getManagedBeanScopeType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanTypeImpl <em>Managed Bean Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getManagedBeanType()
-	 * @generated
-	 */
-	EClass MANAGED_BEAN_TYPE = FacesConfigPackage.eINSTANCE.getManagedBeanType();
-
-	/**
-	 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MANAGED_BEAN_TYPE__DESCRIPTION = FacesConfigPackage.eINSTANCE.getManagedBeanType_Description();
-
-	/**
-	 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MANAGED_BEAN_TYPE__DISPLAY_NAME = FacesConfigPackage.eINSTANCE.getManagedBeanType_DisplayName();
-
-	/**
-	 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MANAGED_BEAN_TYPE__ICON = FacesConfigPackage.eINSTANCE.getManagedBeanType_Icon();
-
-	/**
-	 * The meta object literal for the '<em><b>Managed Bean Name</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MANAGED_BEAN_TYPE__MANAGED_BEAN_NAME = FacesConfigPackage.eINSTANCE.getManagedBeanType_ManagedBeanName();
-
-	/**
-	 * The meta object literal for the '<em><b>Managed Bean Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MANAGED_BEAN_TYPE__MANAGED_BEAN_CLASS = FacesConfigPackage.eINSTANCE.getManagedBeanType_ManagedBeanClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Managed Bean Scope</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MANAGED_BEAN_TYPE__MANAGED_BEAN_SCOPE = FacesConfigPackage.eINSTANCE.getManagedBeanType_ManagedBeanScope();
-
-	/**
-	 * The meta object literal for the '<em><b>Managed Property</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MANAGED_BEAN_TYPE__MANAGED_PROPERTY = FacesConfigPackage.eINSTANCE.getManagedBeanType_ManagedProperty();
-
-	/**
-	 * The meta object literal for the '<em><b>Map Entries</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MANAGED_BEAN_TYPE__MAP_ENTRIES = FacesConfigPackage.eINSTANCE.getManagedBeanType_MapEntries();
-
-	/**
-	 * The meta object literal for the '<em><b>List Entries</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MANAGED_BEAN_TYPE__LIST_ENTRIES = FacesConfigPackage.eINSTANCE.getManagedBeanType_ListEntries();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute MANAGED_BEAN_TYPE__ID = FacesConfigPackage.eINSTANCE.getManagedBeanType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedPropertyTypeImpl <em>Managed Property Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedPropertyTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getManagedPropertyType()
-	 * @generated
-	 */
-	EClass MANAGED_PROPERTY_TYPE = FacesConfigPackage.eINSTANCE.getManagedPropertyType();
-
-	/**
-	 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MANAGED_PROPERTY_TYPE__DESCRIPTION = FacesConfigPackage.eINSTANCE.getManagedPropertyType_Description();
-
-	/**
-	 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MANAGED_PROPERTY_TYPE__DISPLAY_NAME = FacesConfigPackage.eINSTANCE.getManagedPropertyType_DisplayName();
-
-	/**
-	 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MANAGED_PROPERTY_TYPE__ICON = FacesConfigPackage.eINSTANCE.getManagedPropertyType_Icon();
-
-	/**
-	 * The meta object literal for the '<em><b>Property Name</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MANAGED_PROPERTY_TYPE__PROPERTY_NAME = FacesConfigPackage.eINSTANCE.getManagedPropertyType_PropertyName();
-
-	/**
-	 * The meta object literal for the '<em><b>Property Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MANAGED_PROPERTY_TYPE__PROPERTY_CLASS = FacesConfigPackage.eINSTANCE.getManagedPropertyType_PropertyClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Map Entries</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MANAGED_PROPERTY_TYPE__MAP_ENTRIES = FacesConfigPackage.eINSTANCE.getManagedPropertyType_MapEntries();
-
-	/**
-	 * The meta object literal for the '<em><b>Null Value</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MANAGED_PROPERTY_TYPE__NULL_VALUE = FacesConfigPackage.eINSTANCE.getManagedPropertyType_NullValue();
-
-	/**
-	 * The meta object literal for the '<em><b>Value</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MANAGED_PROPERTY_TYPE__VALUE = FacesConfigPackage.eINSTANCE.getManagedPropertyType_Value();
-
-	/**
-	 * The meta object literal for the '<em><b>List Entries</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MANAGED_PROPERTY_TYPE__LIST_ENTRIES = FacesConfigPackage.eINSTANCE.getManagedPropertyType_ListEntries();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute MANAGED_PROPERTY_TYPE__ID = FacesConfigPackage.eINSTANCE.getManagedPropertyType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.MapEntriesTypeImpl <em>Map Entries Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.MapEntriesTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getMapEntriesType()
-	 * @generated
-	 */
-	EClass MAP_ENTRIES_TYPE = FacesConfigPackage.eINSTANCE.getMapEntriesType();
-
-	/**
-	 * The meta object literal for the '<em><b>Key Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MAP_ENTRIES_TYPE__KEY_CLASS = FacesConfigPackage.eINSTANCE.getMapEntriesType_KeyClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Value Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MAP_ENTRIES_TYPE__VALUE_CLASS = FacesConfigPackage.eINSTANCE.getMapEntriesType_ValueClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Map Entry</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MAP_ENTRIES_TYPE__MAP_ENTRY = FacesConfigPackage.eINSTANCE.getMapEntriesType_MapEntry();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute MAP_ENTRIES_TYPE__ID = FacesConfigPackage.eINSTANCE.getMapEntriesType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.MapEntryTypeImpl <em>Map Entry Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.MapEntryTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getMapEntryType()
-	 * @generated
-	 */
-	EClass MAP_ENTRY_TYPE = FacesConfigPackage.eINSTANCE.getMapEntryType();
-
-	/**
-	 * The meta object literal for the '<em><b>Key</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MAP_ENTRY_TYPE__KEY = FacesConfigPackage.eINSTANCE.getMapEntryType_Key();
-
-	/**
-	 * The meta object literal for the '<em><b>Null Value</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MAP_ENTRY_TYPE__NULL_VALUE = FacesConfigPackage.eINSTANCE.getMapEntryType_NullValue();
-
-	/**
-	 * The meta object literal for the '<em><b>Value</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference MAP_ENTRY_TYPE__VALUE = FacesConfigPackage.eINSTANCE.getMapEntryType_Value();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute MAP_ENTRY_TYPE__ID = FacesConfigPackage.eINSTANCE.getMapEntryType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.MessageBundleTypeImpl <em>Message Bundle Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.MessageBundleTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getMessageBundleType()
-	 * @generated
-	 */
-	EClass MESSAGE_BUNDLE_TYPE = FacesConfigPackage.eINSTANCE.getMessageBundleType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute MESSAGE_BUNDLE_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getMessageBundleType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute MESSAGE_BUNDLE_TYPE__ID = FacesConfigPackage.eINSTANCE.getMessageBundleType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationCaseTypeImpl <em>Navigation Case Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationCaseTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getNavigationCaseType()
-	 * @generated
-	 */
-	EClass NAVIGATION_CASE_TYPE = FacesConfigPackage.eINSTANCE.getNavigationCaseType();
-
-	/**
-	 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference NAVIGATION_CASE_TYPE__DESCRIPTION = FacesConfigPackage.eINSTANCE.getNavigationCaseType_Description();
-
-	/**
-	 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference NAVIGATION_CASE_TYPE__DISPLAY_NAME = FacesConfigPackage.eINSTANCE.getNavigationCaseType_DisplayName();
-
-	/**
-	 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference NAVIGATION_CASE_TYPE__ICON = FacesConfigPackage.eINSTANCE.getNavigationCaseType_Icon();
-
-	/**
-	 * The meta object literal for the '<em><b>From Action</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference NAVIGATION_CASE_TYPE__FROM_ACTION = FacesConfigPackage.eINSTANCE.getNavigationCaseType_FromAction();
-
-	/**
-	 * The meta object literal for the '<em><b>From Outcome</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference NAVIGATION_CASE_TYPE__FROM_OUTCOME = FacesConfigPackage.eINSTANCE.getNavigationCaseType_FromOutcome();
-
-	/**
-	 * The meta object literal for the '<em><b>To View Id</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference NAVIGATION_CASE_TYPE__TO_VIEW_ID = FacesConfigPackage.eINSTANCE.getNavigationCaseType_ToViewId();
-
-	/**
-	 * The meta object literal for the '<em><b>Redirect</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference NAVIGATION_CASE_TYPE__REDIRECT = FacesConfigPackage.eINSTANCE.getNavigationCaseType_Redirect();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute NAVIGATION_CASE_TYPE__ID = FacesConfigPackage.eINSTANCE.getNavigationCaseType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationHandlerTypeImpl <em>Navigation Handler Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationHandlerTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getNavigationHandlerType()
-	 * @generated
-	 */
-	EClass NAVIGATION_HANDLER_TYPE = FacesConfigPackage.eINSTANCE.getNavigationHandlerType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute NAVIGATION_HANDLER_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getNavigationHandlerType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute NAVIGATION_HANDLER_TYPE__ID = FacesConfigPackage.eINSTANCE.getNavigationHandlerType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationRuleTypeImpl <em>Navigation Rule Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationRuleTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getNavigationRuleType()
-	 * @generated
-	 */
-	EClass NAVIGATION_RULE_TYPE = FacesConfigPackage.eINSTANCE.getNavigationRuleType();
-
-	/**
-	 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference NAVIGATION_RULE_TYPE__DESCRIPTION = FacesConfigPackage.eINSTANCE.getNavigationRuleType_Description();
-
-	/**
-	 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference NAVIGATION_RULE_TYPE__DISPLAY_NAME = FacesConfigPackage.eINSTANCE.getNavigationRuleType_DisplayName();
-
-	/**
-	 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference NAVIGATION_RULE_TYPE__ICON = FacesConfigPackage.eINSTANCE.getNavigationRuleType_Icon();
-
-	/**
-	 * The meta object literal for the '<em><b>From View Id</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference NAVIGATION_RULE_TYPE__FROM_VIEW_ID = FacesConfigPackage.eINSTANCE.getNavigationRuleType_FromViewId();
-
-	/**
-	 * The meta object literal for the '<em><b>Navigation Case</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference NAVIGATION_RULE_TYPE__NAVIGATION_CASE = FacesConfigPackage.eINSTANCE.getNavigationRuleType_NavigationCase();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute NAVIGATION_RULE_TYPE__ID = FacesConfigPackage.eINSTANCE.getNavigationRuleType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NullValueTypeImpl <em>Null Value Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.NullValueTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getNullValueType()
-	 * @generated
-	 */
-	EClass NULL_VALUE_TYPE = FacesConfigPackage.eINSTANCE.getNullValueType();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute NULL_VALUE_TYPE__ID = FacesConfigPackage.eINSTANCE.getNullValueType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PhaseListenerTypeImpl <em>Phase Listener Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.PhaseListenerTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getPhaseListenerType()
-	 * @generated
-	 */
-	EClass PHASE_LISTENER_TYPE = FacesConfigPackage.eINSTANCE.getPhaseListenerType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute PHASE_LISTENER_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getPhaseListenerType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute PHASE_LISTENER_TYPE__ID = FacesConfigPackage.eINSTANCE.getPhaseListenerType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyClassTypeImpl <em>Property Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getPropertyClassType()
-	 * @generated
-	 */
-	EClass PROPERTY_CLASS_TYPE = FacesConfigPackage.eINSTANCE.getPropertyClassType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute PROPERTY_CLASS_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getPropertyClassType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute PROPERTY_CLASS_TYPE__ID = FacesConfigPackage.eINSTANCE.getPropertyClassType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyExtensionTypeImpl <em>Property Extension Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyExtensionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getPropertyExtensionType()
-	 * @generated
-	 */
-	EClass PROPERTY_EXTENSION_TYPE = FacesConfigPackage.eINSTANCE.getPropertyExtensionType();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyNameTypeImpl <em>Property Name Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyNameTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getPropertyNameType()
-	 * @generated
-	 */
-	EClass PROPERTY_NAME_TYPE = FacesConfigPackage.eINSTANCE.getPropertyNameType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute PROPERTY_NAME_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getPropertyNameType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute PROPERTY_NAME_TYPE__ID = FacesConfigPackage.eINSTANCE.getPropertyNameType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyResolverTypeImpl <em>Property Resolver Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyResolverTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getPropertyResolverType()
-	 * @generated
-	 */
-	EClass PROPERTY_RESOLVER_TYPE = FacesConfigPackage.eINSTANCE.getPropertyResolverType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute PROPERTY_RESOLVER_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getPropertyResolverType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute PROPERTY_RESOLVER_TYPE__ID = FacesConfigPackage.eINSTANCE.getPropertyResolverType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyTypeImpl <em>Property Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getPropertyType()
-	 * @generated
-	 */
-	EClass PROPERTY_TYPE = FacesConfigPackage.eINSTANCE.getPropertyType();
-
-	/**
-	 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference PROPERTY_TYPE__DESCRIPTION = FacesConfigPackage.eINSTANCE.getPropertyType_Description();
-
-	/**
-	 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference PROPERTY_TYPE__DISPLAY_NAME = FacesConfigPackage.eINSTANCE.getPropertyType_DisplayName();
-
-	/**
-	 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference PROPERTY_TYPE__ICON = FacesConfigPackage.eINSTANCE.getPropertyType_Icon();
-
-	/**
-	 * The meta object literal for the '<em><b>Property Name</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference PROPERTY_TYPE__PROPERTY_NAME = FacesConfigPackage.eINSTANCE.getPropertyType_PropertyName();
-
-	/**
-	 * The meta object literal for the '<em><b>Property Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference PROPERTY_TYPE__PROPERTY_CLASS = FacesConfigPackage.eINSTANCE.getPropertyType_PropertyClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Default Value</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference PROPERTY_TYPE__DEFAULT_VALUE = FacesConfigPackage.eINSTANCE.getPropertyType_DefaultValue();
-
-	/**
-	 * The meta object literal for the '<em><b>Suggested Value</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference PROPERTY_TYPE__SUGGESTED_VALUE = FacesConfigPackage.eINSTANCE.getPropertyType_SuggestedValue();
-
-	/**
-	 * The meta object literal for the '<em><b>Property Extension</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference PROPERTY_TYPE__PROPERTY_EXTENSION = FacesConfigPackage.eINSTANCE.getPropertyType_PropertyExtension();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute PROPERTY_TYPE__ID = FacesConfigPackage.eINSTANCE.getPropertyType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RedirectTypeImpl <em>Redirect Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RedirectTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRedirectType()
-	 * @generated
-	 */
-	EClass REDIRECT_TYPE = FacesConfigPackage.eINSTANCE.getRedirectType();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute REDIRECT_TYPE__ID = FacesConfigPackage.eINSTANCE.getRedirectType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanClassTypeImpl <em>Referenced Bean Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getReferencedBeanClassType()
-	 * @generated
-	 */
-	EClass REFERENCED_BEAN_CLASS_TYPE = FacesConfigPackage.eINSTANCE.getReferencedBeanClassType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute REFERENCED_BEAN_CLASS_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getReferencedBeanClassType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute REFERENCED_BEAN_CLASS_TYPE__ID = FacesConfigPackage.eINSTANCE.getReferencedBeanClassType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanNameTypeImpl <em>Referenced Bean Name Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanNameTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getReferencedBeanNameType()
-	 * @generated
-	 */
-	EClass REFERENCED_BEAN_NAME_TYPE = FacesConfigPackage.eINSTANCE.getReferencedBeanNameType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute REFERENCED_BEAN_NAME_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getReferencedBeanNameType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute REFERENCED_BEAN_NAME_TYPE__ID = FacesConfigPackage.eINSTANCE.getReferencedBeanNameType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanTypeImpl <em>Referenced Bean Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getReferencedBeanType()
-	 * @generated
-	 */
-	EClass REFERENCED_BEAN_TYPE = FacesConfigPackage.eINSTANCE.getReferencedBeanType();
-
-	/**
-	 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference REFERENCED_BEAN_TYPE__DESCRIPTION = FacesConfigPackage.eINSTANCE.getReferencedBeanType_Description();
-
-	/**
-	 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference REFERENCED_BEAN_TYPE__DISPLAY_NAME = FacesConfigPackage.eINSTANCE.getReferencedBeanType_DisplayName();
-
-	/**
-	 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference REFERENCED_BEAN_TYPE__ICON = FacesConfigPackage.eINSTANCE.getReferencedBeanType_Icon();
-
-	/**
-	 * The meta object literal for the '<em><b>Referenced Bean Name</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference REFERENCED_BEAN_TYPE__REFERENCED_BEAN_NAME = FacesConfigPackage.eINSTANCE.getReferencedBeanType_ReferencedBeanName();
-
-	/**
-	 * The meta object literal for the '<em><b>Referenced Bean Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference REFERENCED_BEAN_TYPE__REFERENCED_BEAN_CLASS = FacesConfigPackage.eINSTANCE.getReferencedBeanType_ReferencedBeanClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute REFERENCED_BEAN_TYPE__ID = FacesConfigPackage.eINSTANCE.getReferencedBeanType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererClassTypeImpl <em>Renderer Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RendererClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRendererClassType()
-	 * @generated
-	 */
-	EClass RENDERER_CLASS_TYPE = FacesConfigPackage.eINSTANCE.getRendererClassType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute RENDERER_CLASS_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getRendererClassType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute RENDERER_CLASS_TYPE__ID = FacesConfigPackage.eINSTANCE.getRendererClassType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererExtensionTypeImpl <em>Renderer Extension Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RendererExtensionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRendererExtensionType()
-	 * @generated
-	 */
-	EClass RENDERER_EXTENSION_TYPE = FacesConfigPackage.eINSTANCE.getRendererExtensionType();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeImpl <em>Renderer Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRendererType()
-	 * @generated
-	 */
-	EClass RENDERER_TYPE = FacesConfigPackage.eINSTANCE.getRendererType();
-
-	/**
-	 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference RENDERER_TYPE__DESCRIPTION = FacesConfigPackage.eINSTANCE.getRendererType_Description();
-
-	/**
-	 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference RENDERER_TYPE__DISPLAY_NAME = FacesConfigPackage.eINSTANCE.getRendererType_DisplayName();
-
-	/**
-	 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference RENDERER_TYPE__ICON = FacesConfigPackage.eINSTANCE.getRendererType_Icon();
-
-	/**
-	 * The meta object literal for the '<em><b>Component Family</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference RENDERER_TYPE__COMPONENT_FAMILY = FacesConfigPackage.eINSTANCE.getRendererType_ComponentFamily();
-
-	/**
-	 * The meta object literal for the '<em><b>Renderer Type</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference RENDERER_TYPE__RENDERER_TYPE = FacesConfigPackage.eINSTANCE.getRendererType_RendererType();
-
-	/**
-	 * The meta object literal for the '<em><b>Renderer Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference RENDERER_TYPE__RENDERER_CLASS = FacesConfigPackage.eINSTANCE.getRendererType_RendererClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Facet</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference RENDERER_TYPE__FACET = FacesConfigPackage.eINSTANCE.getRendererType_Facet();
-
-	/**
-	 * The meta object literal for the '<em><b>Attribute</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference RENDERER_TYPE__ATTRIBUTE = FacesConfigPackage.eINSTANCE.getRendererType_Attribute();
-
-	/**
-	 * The meta object literal for the '<em><b>Renderer Extension</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference RENDERER_TYPE__RENDERER_EXTENSION = FacesConfigPackage.eINSTANCE.getRendererType_RendererExtension();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute RENDERER_TYPE__ID = FacesConfigPackage.eINSTANCE.getRendererType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeTypeImpl <em>Renderer Type Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRendererTypeType()
-	 * @generated
-	 */
-	EClass RENDERER_TYPE_TYPE = FacesConfigPackage.eINSTANCE.getRendererTypeType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute RENDERER_TYPE_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getRendererTypeType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute RENDERER_TYPE_TYPE__ID = FacesConfigPackage.eINSTANCE.getRendererTypeType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitClassTypeImpl <em>Render Kit Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRenderKitClassType()
-	 * @generated
-	 */
-	EClass RENDER_KIT_CLASS_TYPE = FacesConfigPackage.eINSTANCE.getRenderKitClassType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute RENDER_KIT_CLASS_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getRenderKitClassType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute RENDER_KIT_CLASS_TYPE__ID = FacesConfigPackage.eINSTANCE.getRenderKitClassType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitFactoryTypeImpl <em>Render Kit Factory Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitFactoryTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRenderKitFactoryType()
-	 * @generated
-	 */
-	EClass RENDER_KIT_FACTORY_TYPE = FacesConfigPackage.eINSTANCE.getRenderKitFactoryType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute RENDER_KIT_FACTORY_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getRenderKitFactoryType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute RENDER_KIT_FACTORY_TYPE__ID = FacesConfigPackage.eINSTANCE.getRenderKitFactoryType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitIdTypeImpl <em>Render Kit Id Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitIdTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRenderKitIdType()
-	 * @generated
-	 */
-	EClass RENDER_KIT_ID_TYPE = FacesConfigPackage.eINSTANCE.getRenderKitIdType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute RENDER_KIT_ID_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getRenderKitIdType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute RENDER_KIT_ID_TYPE__ID = FacesConfigPackage.eINSTANCE.getRenderKitIdType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitTypeImpl <em>Render Kit Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRenderKitType()
-	 * @generated
-	 */
-	EClass RENDER_KIT_TYPE = FacesConfigPackage.eINSTANCE.getRenderKitType();
-
-	/**
-	 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference RENDER_KIT_TYPE__DESCRIPTION = FacesConfigPackage.eINSTANCE.getRenderKitType_Description();
-
-	/**
-	 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference RENDER_KIT_TYPE__DISPLAY_NAME = FacesConfigPackage.eINSTANCE.getRenderKitType_DisplayName();
-
-	/**
-	 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference RENDER_KIT_TYPE__ICON = FacesConfigPackage.eINSTANCE.getRenderKitType_Icon();
-
-	/**
-	 * The meta object literal for the '<em><b>Render Kit Id</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference RENDER_KIT_TYPE__RENDER_KIT_ID = FacesConfigPackage.eINSTANCE.getRenderKitType_RenderKitId();
-
-	/**
-	 * The meta object literal for the '<em><b>Render Kit Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference RENDER_KIT_TYPE__RENDER_KIT_CLASS = FacesConfigPackage.eINSTANCE.getRenderKitType_RenderKitClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Renderer</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference RENDER_KIT_TYPE__RENDERER = FacesConfigPackage.eINSTANCE.getRenderKitType_Renderer();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute RENDER_KIT_TYPE__ID = FacesConfigPackage.eINSTANCE.getRenderKitType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SmallIconTypeImpl <em>Small Icon Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.SmallIconTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getSmallIconType()
-	 * @generated
-	 */
-	EClass SMALL_ICON_TYPE = FacesConfigPackage.eINSTANCE.getSmallIconType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute SMALL_ICON_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getSmallIconType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute SMALL_ICON_TYPE__ID = FacesConfigPackage.eINSTANCE.getSmallIconType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.StateManagerTypeImpl <em>State Manager Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.StateManagerTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getStateManagerType()
-	 * @generated
-	 */
-	EClass STATE_MANAGER_TYPE = FacesConfigPackage.eINSTANCE.getStateManagerType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute STATE_MANAGER_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getStateManagerType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute STATE_MANAGER_TYPE__ID = FacesConfigPackage.eINSTANCE.getStateManagerType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SuggestedValueTypeImpl <em>Suggested Value Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.SuggestedValueTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getSuggestedValueType()
-	 * @generated
-	 */
-	EClass SUGGESTED_VALUE_TYPE = FacesConfigPackage.eINSTANCE.getSuggestedValueType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute SUGGESTED_VALUE_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getSuggestedValueType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute SUGGESTED_VALUE_TYPE__ID = FacesConfigPackage.eINSTANCE.getSuggestedValueType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SupportedLocaleTypeImpl <em>Supported Locale Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.SupportedLocaleTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getSupportedLocaleType()
-	 * @generated
-	 */
-	EClass SUPPORTED_LOCALE_TYPE = FacesConfigPackage.eINSTANCE.getSupportedLocaleType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute SUPPORTED_LOCALE_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getSupportedLocaleType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute SUPPORTED_LOCALE_TYPE__ID = FacesConfigPackage.eINSTANCE.getSupportedLocaleType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ToViewIdTypeImpl <em>To View Id Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ToViewIdTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getToViewIdType()
-	 * @generated
-	 */
-	EClass TO_VIEW_ID_TYPE = FacesConfigPackage.eINSTANCE.getToViewIdType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute TO_VIEW_ID_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getToViewIdType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute TO_VIEW_ID_TYPE__ID = FacesConfigPackage.eINSTANCE.getToViewIdType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorClassTypeImpl <em>Validator Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getValidatorClassType()
-	 * @generated
-	 */
-	EClass VALIDATOR_CLASS_TYPE = FacesConfigPackage.eINSTANCE.getValidatorClassType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute VALIDATOR_CLASS_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getValidatorClassType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute VALIDATOR_CLASS_TYPE__ID = FacesConfigPackage.eINSTANCE.getValidatorClassType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorIdTypeImpl <em>Validator Id Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorIdTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getValidatorIdType()
-	 * @generated
-	 */
-	EClass VALIDATOR_ID_TYPE = FacesConfigPackage.eINSTANCE.getValidatorIdType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute VALIDATOR_ID_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getValidatorIdType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute VALIDATOR_ID_TYPE__ID = FacesConfigPackage.eINSTANCE.getValidatorIdType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorTypeImpl <em>Validator Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getValidatorType()
-	 * @generated
-	 */
-	EClass VALIDATOR_TYPE = FacesConfigPackage.eINSTANCE.getValidatorType();
-
-	/**
-	 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference VALIDATOR_TYPE__DESCRIPTION = FacesConfigPackage.eINSTANCE.getValidatorType_Description();
-
-	/**
-	 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference VALIDATOR_TYPE__DISPLAY_NAME = FacesConfigPackage.eINSTANCE.getValidatorType_DisplayName();
-
-	/**
-	 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference VALIDATOR_TYPE__ICON = FacesConfigPackage.eINSTANCE.getValidatorType_Icon();
-
-	/**
-	 * The meta object literal for the '<em><b>Validator Id</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference VALIDATOR_TYPE__VALIDATOR_ID = FacesConfigPackage.eINSTANCE.getValidatorType_ValidatorId();
-
-	/**
-	 * The meta object literal for the '<em><b>Validator Class</b></em>' containment reference feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference VALIDATOR_TYPE__VALIDATOR_CLASS = FacesConfigPackage.eINSTANCE.getValidatorType_ValidatorClass();
-
-	/**
-	 * The meta object literal for the '<em><b>Attribute</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference VALIDATOR_TYPE__ATTRIBUTE = FacesConfigPackage.eINSTANCE.getValidatorType_Attribute();
-
-	/**
-	 * The meta object literal for the '<em><b>Property</b></em>' containment reference list feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EReference VALIDATOR_TYPE__PROPERTY = FacesConfigPackage.eINSTANCE.getValidatorType_Property();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute VALIDATOR_TYPE__ID = FacesConfigPackage.eINSTANCE.getValidatorType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValueClassTypeImpl <em>Value Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ValueClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getValueClassType()
-	 * @generated
-	 */
-	EClass VALUE_CLASS_TYPE = FacesConfigPackage.eINSTANCE.getValueClassType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute VALUE_CLASS_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getValueClassType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute VALUE_CLASS_TYPE__ID = FacesConfigPackage.eINSTANCE.getValueClassType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValueTypeImpl <em>Value Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ValueTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getValueType()
-	 * @generated
-	 */
-	EClass VALUE_TYPE = FacesConfigPackage.eINSTANCE.getValueType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute VALUE_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getValueType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute VALUE_TYPE__ID = FacesConfigPackage.eINSTANCE.getValueType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.VariableResolverTypeImpl <em>Variable Resolver Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.VariableResolverTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getVariableResolverType()
-	 * @generated
-	 */
-	EClass VARIABLE_RESOLVER_TYPE = FacesConfigPackage.eINSTANCE.getVariableResolverType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute VARIABLE_RESOLVER_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getVariableResolverType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute VARIABLE_RESOLVER_TYPE__ID = FacesConfigPackage.eINSTANCE.getVariableResolverType_Id();
-
-	/**
-	 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ViewHandlerTypeImpl <em>View Handler Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ViewHandlerTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getViewHandlerType()
-	 * @generated
-	 */
-	EClass VIEW_HANDLER_TYPE = FacesConfigPackage.eINSTANCE.getViewHandlerType();
-
-	/**
-	 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute VIEW_HANDLER_TYPE__TEXT_CONTENT = FacesConfigPackage.eINSTANCE.getViewHandlerType_TextContent();
-
-	/**
-	 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	EAttribute VIEW_HANDLER_TYPE__ID = FacesConfigPackage.eINSTANCE.getViewHandlerType_Id();
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/LocaleConfigTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/LocaleConfigTypeItemProvider.java
deleted file mode 100644
index adc2f0e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/LocaleConfigTypeItemProvider.java
+++ /dev/null
@@ -1,254 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType;
-import org.eclipse.jst.jsf.facesconfig.emf.SupportedLocaleType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-public class LocaleConfigTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public LocaleConfigTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_LocaleConfigType_id_feature"), //$NON-NLS-1$
-				 getString("_UI_PropertyDescriptor_description", "_UI_LocaleConfigType_id_feature", "_UI_LocaleConfigType_type"),  //$NON-NLS-1$ //$NON-NLS-2$//$NON-NLS-3$
-				 FacesConfigPackage.Literals.LOCALE_CONFIG_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.LOCALE_CONFIG_TYPE__DEFAULT_LOCALE);
-			childrenFeatures.add(FacesConfigPackage.Literals.LOCALE_CONFIG_TYPE__SUPPORTED_LOCALE);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 LocaleConfigType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/LocaleConfigType")); //$NON-NLS-1$
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = null;
-		
-		final StringBuffer buf = new StringBuffer();
-		final LocaleConfigType l = (LocaleConfigType)object;
-		
-		if (l.getDefaultLocale() != null)
-			buf.append(l.getDefaultLocale().getTextContent());
-
-		for (final Object locObj : l.getSupportedLocale()) {
-			final SupportedLocaleType loc = (SupportedLocaleType)locObj;
-			if (loc.getTextContent() != null) {
-				if (buf.toString() != null) {
-					buf.append(',');
-				}
-				buf.append(loc.getTextContent());
-			}
-		}
-		label = buf.toString();
-		
-		return label == null || label.length() == 0 ?
-				getString("_UI_LocaleConfigType_type")  //$NON-NLS-1$
-				: label;
-
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(LocaleConfigType.class)) {
-			case FacesConfigPackage.LOCALE_CONFIG_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.LOCALE_CONFIG_TYPE__DEFAULT_LOCALE:
-			case FacesConfigPackage.LOCALE_CONFIG_TYPE__SUPPORTED_LOCALE:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.LOCALE_CONFIG_TYPE__DEFAULT_LOCALE,
-				 FacesConfigFactory.eINSTANCE.createDefaultLocaleType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.LOCALE_CONFIG_TYPE__SUPPORTED_LOCALE,
-				 FacesConfigFactory.eINSTANCE.createSupportedLocaleType()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		// TODO Auto-generated method stub
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_LocaleConfigType_type"); //$NON-NLS-1$
-		}
-
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ManagedBeanClassTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ManagedBeanClassTypeItemProvider.java
deleted file mode 100644
index 79c2e98..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ManagedBeanClassTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanClassType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanClassType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ManagedBeanClassTypeItemProvider
-    extends ItemProviderAdapter
-    implements	
-        IEditingDomainItemProvider,	
-        IStructuredItemContentProvider,	
-        ITreeItemContentProvider,	
-        IItemLabelProvider,	
-        IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ManagedBeanClassTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ManagedBeanClassType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ManagedBeanClassType_textContent_feature", "_UI_ManagedBeanClassType_type"),
-				 FacesConfigPackage.Literals.MANAGED_BEAN_CLASS_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ManagedBeanClassType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ManagedBeanClassType_id_feature", "_UI_ManagedBeanClassType_type"),
-				 FacesConfigPackage.Literals.MANAGED_BEAN_CLASS_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns ManagedBeanClassType.gif.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ManagedBeanClassType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getText(Object object) {
-		String label = ((ManagedBeanClassType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ManagedBeanClassType_type") :
-			getString("_UI_ManagedBeanClassType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-    public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ManagedBeanClassType.class)) {
-			case FacesConfigPackage.MANAGED_BEAN_CLASS_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.MANAGED_BEAN_CLASS_TYPE__ID:
-				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
-	 */
-    protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ManagedBeanExtensionTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ManagedBeanExtensionTypeItemProvider.java
deleted file mode 100644
index 844f736..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ManagedBeanExtensionTypeItemProvider.java
+++ /dev/null
@@ -1,121 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.edit.provider.IEditingDomainItemProvider;
-import org.eclipse.emf.edit.provider.IItemLabelProvider;
-import org.eclipse.emf.edit.provider.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanExtensionType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanExtensionType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ManagedBeanExtensionTypeItemProvider
-    extends ExtensionTypeItemProvider
-    implements	
-        IEditingDomainItemProvider,	
-        IStructuredItemContentProvider,	
-        ITreeItemContentProvider,	
-        IItemLabelProvider,	
-        IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    @SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ManagedBeanExtensionTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This returns ManagedBeanExtensionType.gif.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ManagedBeanExtensionType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getText(Object object) {
-		String label = ((ManagedBeanExtensionType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ManagedBeanExtensionType_type") :
-			getString("_UI_ManagedBeanExtensionType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-    public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-		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
-	 */
-    protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ManagedBeanNameTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ManagedBeanNameTypeItemProvider.java
deleted file mode 100644
index 8393274..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ManagedBeanNameTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanNameType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanNameType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ManagedBeanNameTypeItemProvider
-    extends ItemProviderAdapter
-    implements	
-        IEditingDomainItemProvider,	
-        IStructuredItemContentProvider,	
-        ITreeItemContentProvider,	
-        IItemLabelProvider,	
-        IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ManagedBeanNameTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ManagedBeanNameType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ManagedBeanNameType_textContent_feature", "_UI_ManagedBeanNameType_type"),
-				 FacesConfigPackage.Literals.MANAGED_BEAN_NAME_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ManagedBeanNameType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ManagedBeanNameType_id_feature", "_UI_ManagedBeanNameType_type"),
-				 FacesConfigPackage.Literals.MANAGED_BEAN_NAME_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns ManagedBeanNameType.gif.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ManagedBeanNameType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getText(Object object) {
-		String label = ((ManagedBeanNameType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ManagedBeanNameType_type") :
-			getString("_UI_ManagedBeanNameType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-    public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ManagedBeanNameType.class)) {
-			case FacesConfigPackage.MANAGED_BEAN_NAME_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.MANAGED_BEAN_NAME_TYPE__ID:
-				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
-	 */
-    protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ManagedBeanScopeTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ManagedBeanScopeTypeItemProvider.java
deleted file mode 100644
index a402249..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ManagedBeanScopeTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanScopeType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanScopeType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ManagedBeanScopeTypeItemProvider
-    extends ItemProviderAdapter
-    implements	
-        IEditingDomainItemProvider,	
-        IStructuredItemContentProvider,	
-        ITreeItemContentProvider,	
-        IItemLabelProvider,	
-        IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ManagedBeanScopeTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ManagedBeanScopeType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ManagedBeanScopeType_textContent_feature", "_UI_ManagedBeanScopeType_type"),
-				 FacesConfigPackage.Literals.MANAGED_BEAN_SCOPE_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ManagedBeanScopeType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ManagedBeanScopeType_id_feature", "_UI_ManagedBeanScopeType_type"),
-				 FacesConfigPackage.Literals.MANAGED_BEAN_SCOPE_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns ManagedBeanScopeType.gif.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ManagedBeanScopeType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getText(Object object) {
-		String label = ((ManagedBeanScopeType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ManagedBeanScopeType_type") :
-			getString("_UI_ManagedBeanScopeType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-    public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ManagedBeanScopeType.class)) {
-			case FacesConfigPackage.MANAGED_BEAN_SCOPE_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.MANAGED_BEAN_SCOPE_TYPE__ID:
-				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
-	 */
-    protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ManagedBeanTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ManagedBeanTypeItemProvider.java
deleted file mode 100644
index e3238b3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ManagedBeanTypeItemProvider.java
+++ /dev/null
@@ -1,324 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ManagedBeanTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ManagedBeanTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-			addEagerPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ManagedBeanType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ManagedBeanType_id_feature", "_UI_ManagedBeanType_type"),
-				 FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Eager feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc --> 
-	 * @generated
-	 */
-	protected void addEagerPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ManagedBeanType_eager_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ManagedBeanType_eager_feature", "_UI_ManagedBeanType_type"),
-				 FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__EAGER,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-				/**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__DESCRIPTION);
-			childrenFeatures.add(FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__DISPLAY_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__ICON);
-			childrenFeatures.add(FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__MANAGED_BEAN_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__MANAGED_BEAN_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__MANAGED_BEAN_SCOPE);
-			childrenFeatures.add(FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__MANAGED_PROPERTY);
-			childrenFeatures.add(FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__MAP_ENTRIES);
-			childrenFeatures.add(FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__LIST_ENTRIES);
-			childrenFeatures.add(FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__MANAGED_BEAN_EXTENSION);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 ManagedBeanType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ManagedBeanType"));
-	}
-
-    /**
-     * This returns the label text for the adapted class.
-     * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-     * @generated NOT
-     */
-	public String getText(Object object) {
-        String label = null;
-        if (((ManagedBeanType) object).getManagedBeanName() != null)
-        {
-            label = ((ManagedBeanType) object).getManagedBeanName()
-                    .getTextContent();
-        }
-        if (label == null || label.length() == 0) {
-            if (((ManagedBeanType) object).getManagedBeanClass() != null)
-                label = ((ManagedBeanType) object).getManagedBeanClass()
-                        .getTextContent();
-        }
-        return label == null || label.length() == 0 ? getString("_UI_ManagedBeanType_type") //$NON-NLS-1$
-                : label;
-    }
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ManagedBeanType.class)) {
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__ID:
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__EAGER:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__DESCRIPTION:
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__DISPLAY_NAME:
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__ICON:
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_NAME:
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_CLASS:
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_SCOPE:
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_PROPERTY:
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MAP_ENTRIES:
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__LIST_ENTRIES:
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_EXTENSION:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__DESCRIPTION,
-				 FacesConfigFactory.eINSTANCE.createDescriptionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__DISPLAY_NAME,
-				 FacesConfigFactory.eINSTANCE.createDisplayNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__ICON,
-				 FacesConfigFactory.eINSTANCE.createIconType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__MANAGED_BEAN_NAME,
-				 FacesConfigFactory.eINSTANCE.createManagedBeanNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__MANAGED_BEAN_CLASS,
-				 FacesConfigFactory.eINSTANCE.createManagedBeanClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__MANAGED_BEAN_SCOPE,
-				 FacesConfigFactory.eINSTANCE.createManagedBeanScopeType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__MANAGED_PROPERTY,
-				 FacesConfigFactory.eINSTANCE.createManagedPropertyType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__MAP_ENTRIES,
-				 FacesConfigFactory.eINSTANCE.createMapEntriesType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__LIST_ENTRIES,
-				 FacesConfigFactory.eINSTANCE.createListEntriesType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MANAGED_BEAN_TYPE__MANAGED_BEAN_EXTENSION,
-				 FacesConfigFactory.eINSTANCE.createManagedBeanExtensionType()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	public Object getColumnImage(Object object, int columnIndex) {
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	public String getColumnText(Object object, int columnIndex) {
-		ManagedBeanType managedBean = (ManagedBeanType) object;
-		switch (columnIndex) {
-
-		case 0:
-			return managedBean.getManagedBeanName() == null ? "" : managedBean //$NON-NLS-1$
-					.getManagedBeanName().getTextContent();
-		case 1:
-			return managedBean.getManagedBeanScope() == null ? "" : managedBean //$NON-NLS-1$
-					.getManagedBeanScope().getTextContent();
-
-		case 2:
-			return managedBean.getManagedBeanClass() == null ? "" : managedBean //$NON-NLS-1$
-					.getManagedBeanClass().getTextContent();
-		}
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ManagedPropertyTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ManagedPropertyTypeItemProvider.java
deleted file mode 100644
index 2b05a4f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ManagedPropertyTypeItemProvider.java
+++ /dev/null
@@ -1,293 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-public class ManagedPropertyTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider{
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ManagedPropertyTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ManagedPropertyType_id_feature"), //$NON-NLS-1$
-				 getString("_UI_PropertyDescriptor_description", "_UI_ManagedPropertyType_id_feature", "_UI_ManagedPropertyType_type"),  //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
-				 FacesConfigPackage.Literals.MANAGED_PROPERTY_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.MANAGED_PROPERTY_TYPE__DESCRIPTION);
-			childrenFeatures.add(FacesConfigPackage.Literals.MANAGED_PROPERTY_TYPE__DISPLAY_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.MANAGED_PROPERTY_TYPE__ICON);
-			childrenFeatures.add(FacesConfigPackage.Literals.MANAGED_PROPERTY_TYPE__PROPERTY_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.MANAGED_PROPERTY_TYPE__PROPERTY_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.MANAGED_PROPERTY_TYPE__MAP_ENTRIES);
-			childrenFeatures.add(FacesConfigPackage.Literals.MANAGED_PROPERTY_TYPE__NULL_VALUE);
-			childrenFeatures.add(FacesConfigPackage.Literals.MANAGED_PROPERTY_TYPE__VALUE);
-			childrenFeatures.add(FacesConfigPackage.Literals.MANAGED_PROPERTY_TYPE__LIST_ENTRIES);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 ManagedPropertyType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ManagedPropertyType")); //$NON-NLS-1$
-	}
-
-    /**
-     * This returns the label text for the adapted class.
-     * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-     * @generated NOT
-     */
-	public String getText(Object object) {
-        String label = ((ManagedPropertyType) object).getId();
-        if (((ManagedPropertyType) object).getPropertyName() != null) {
-            label = ((ManagedPropertyType) object).getPropertyName()
-                    .getTextContent();
-        }
-        return label == null || label.length() == 0 ? getString("_UI_ManagedPropertyType_type") //$NON-NLS-1$
-                : label;
-
-    }
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ManagedPropertyType.class)) {
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__DESCRIPTION:
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__DISPLAY_NAME:
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__ICON:
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__PROPERTY_NAME:
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__PROPERTY_CLASS:
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__MAP_ENTRIES:
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__NULL_VALUE:
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__VALUE:
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__LIST_ENTRIES:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MANAGED_PROPERTY_TYPE__DESCRIPTION,
-				 FacesConfigFactory.eINSTANCE.createDescriptionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MANAGED_PROPERTY_TYPE__DISPLAY_NAME,
-				 FacesConfigFactory.eINSTANCE.createDisplayNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MANAGED_PROPERTY_TYPE__ICON,
-				 FacesConfigFactory.eINSTANCE.createIconType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MANAGED_PROPERTY_TYPE__PROPERTY_NAME,
-				 FacesConfigFactory.eINSTANCE.createPropertyNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MANAGED_PROPERTY_TYPE__PROPERTY_CLASS,
-				 FacesConfigFactory.eINSTANCE.createPropertyClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MANAGED_PROPERTY_TYPE__MAP_ENTRIES,
-				 FacesConfigFactory.eINSTANCE.createMapEntriesType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MANAGED_PROPERTY_TYPE__NULL_VALUE,
-				 FacesConfigFactory.eINSTANCE.createNullValueType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MANAGED_PROPERTY_TYPE__VALUE,
-				 FacesConfigFactory.eINSTANCE.createValueType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MANAGED_PROPERTY_TYPE__LIST_ENTRIES,
-				 FacesConfigFactory.eINSTANCE.createListEntriesType()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	public String getColumnText(Object object, int columnIndex) {
-		ManagedPropertyType attribute = (ManagedPropertyType) object;
-		switch (columnIndex) {
-
-		case 0:
-			return attribute.getPropertyName() == null ? "" : attribute //$NON-NLS-1$
-					.getPropertyName().getTextContent();
-		case 1:
-			return attribute.getPropertyClass() == null ? "" : attribute //$NON-NLS-1$
-					.getPropertyClass().getTextContent();
-		case 2:
-			if(attribute.getValue() != null)
-			{
-				return attribute.getValue().getTextContent();
-			}
-			else if(attribute.getNullValue() != null)
-				return "<null-value>"; //$NON-NLS-1$
-			else if(attribute.getMapEntries() != null)
-				return "<map-entries>"; //$NON-NLS-1$
-			else if(attribute.getListEntries() != null)
-				return "<list-entries>"; //$NON-NLS-1$
-			return ""; //$NON-NLS-1$
-		}
-		return null;
-	}
-
-	public Object getColumnImage(Object object, int columnIndex) {
-		// TODO Auto-generated method stub
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/MapEntriesTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/MapEntriesTypeItemProvider.java
deleted file mode 100644
index 652dab8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/MapEntriesTypeItemProvider.java
+++ /dev/null
@@ -1,219 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class MapEntriesTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public MapEntriesTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_MapEntriesType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_MapEntriesType_id_feature", "_UI_MapEntriesType_type"),
-				 FacesConfigPackage.Literals.MAP_ENTRIES_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.MAP_ENTRIES_TYPE__KEY_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.MAP_ENTRIES_TYPE__VALUE_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.MAP_ENTRIES_TYPE__MAP_ENTRY);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 MapEntriesType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/MapEntriesType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((MapEntriesType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_MapEntriesType_type") :
-			getString("_UI_MapEntriesType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(MapEntriesType.class)) {
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__KEY_CLASS:
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__VALUE_CLASS:
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__MAP_ENTRY:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MAP_ENTRIES_TYPE__KEY_CLASS,
-				 FacesConfigFactory.eINSTANCE.createKeyClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MAP_ENTRIES_TYPE__VALUE_CLASS,
-				 FacesConfigFactory.eINSTANCE.createValueClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MAP_ENTRIES_TYPE__MAP_ENTRY,
-				 FacesConfigFactory.eINSTANCE.createMapEntryType()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/MapEntryTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/MapEntryTypeItemProvider.java
deleted file mode 100644
index 13b4bbb..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/MapEntryTypeItemProvider.java
+++ /dev/null
@@ -1,247 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.KeyType;
-import org.eclipse.jst.jsf.facesconfig.emf.MapEntryType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.MapEntryType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class MapEntryTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource,
-		ITableItemLabelProvider{
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public MapEntryTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_MapEntryType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_MapEntryType_id_feature", "_UI_MapEntryType_type"),
-				 FacesConfigPackage.Literals.MAP_ENTRY_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.MAP_ENTRY_TYPE__KEY);
-			childrenFeatures.add(FacesConfigPackage.Literals.MAP_ENTRY_TYPE__NULL_VALUE);
-			childrenFeatures.add(FacesConfigPackage.Literals.MAP_ENTRY_TYPE__VALUE);
-		}
-		return childrenFeatures;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 MapEntryType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/MapEntryType"));
-	}
-
-    /**
-     * This returns the label text for the adapted class.
-     * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-     * @generated NOT
-     */
-	public String getText(Object object) {
-        KeyType key = ((MapEntryType)object).getKey();
-        
-        String label = key != null ? key.getTextContent() : null;
-        return label == null || label.length() == 0 ?
-            getString("_UI_MapEntryType_type") : label; //$NON-NLS-1$
-    }
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(MapEntryType.class)) {
-			case FacesConfigPackage.MAP_ENTRY_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.MAP_ENTRY_TYPE__KEY:
-			case FacesConfigPackage.MAP_ENTRY_TYPE__NULL_VALUE:
-			case FacesConfigPackage.MAP_ENTRY_TYPE__VALUE:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MAP_ENTRY_TYPE__KEY,
-				 FacesConfigFactory.eINSTANCE.createKeyType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MAP_ENTRY_TYPE__NULL_VALUE,
-				 FacesConfigFactory.eINSTANCE.createNullValueType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.MAP_ENTRY_TYPE__VALUE,
-				 FacesConfigFactory.eINSTANCE.createValueType()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	public String getColumnText(Object object, int columnIndex) {
-
-		MapEntryType mapEntry = (MapEntryType) object;
-		switch (columnIndex) {
-
-		case 0:
-			return mapEntry.getKey() == null ? "" : mapEntry.getKey() //$NON-NLS-1$
-					.getTextContent();
-		case 1:
-			if (mapEntry.getNullValue() != null)
-            {
-				return "<null-value>"; //$NON-NLS-1$
-            }
-			return mapEntry.getValue() == null ? "" : mapEntry.getValue() //$NON-NLS-1$
-					.getTextContent();
-		}
-		return null;
-	}	
-    public Object getColumnImage(Object object, int columnIndex) {
-		// no column images
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/MessageBundleTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/MessageBundleTypeItemProvider.java
deleted file mode 100644
index 56d4ce0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/MessageBundleTypeItemProvider.java
+++ /dev/null
@@ -1,209 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.MessageBundleType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.MessageBundleType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class MessageBundleTypeItemProvider extends ItemProviderAdapter
-		implements IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc --> 
- 	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public MessageBundleTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc --> 
-	 * @param object
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_MessageBundleType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_MessageBundleType_textContent_feature", "_UI_MessageBundleType_type"),
-				 FacesConfigPackage.Literals.MESSAGE_BUNDLE_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc--> 
-     * @param object
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_MessageBundleType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_MessageBundleType_id_feature", "_UI_MessageBundleType_type"),
-				 FacesConfigPackage.Literals.MESSAGE_BUNDLE_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns MessageBundleType.gif.
-	 * <!-- begin-user-doc --> <!--
-	 * end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/MessageBundleType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc
-	 * --> <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((MessageBundleType) object).getTextContent();
-		return label == null || label.length() == 0 ? getString("_UI_MessageBundleType_type")
-				: label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(MessageBundleType.class)) {
-			case FacesConfigPackage.MESSAGE_BUNDLE_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.MESSAGE_BUNDLE_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_MessageBundleType_type"); //$NON-NLS-1$
-		}
-
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/NameTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/NameTypeItemProvider.java
deleted file mode 100644
index 1f8f3bf..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/NameTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.NameType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.NameType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class NameTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory
-	 * <!-- end-user-doc --> 
-	 * @generated
-	 */
-	public NameTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc --> 
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_NameType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_NameType_textContent_feature", "_UI_NameType_type"),
-				 FacesConfigPackage.Literals.NAME_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_NameType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_NameType_id_feature", "_UI_NameType_type"),
-				 FacesConfigPackage.Literals.NAME_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This returns NameType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/NameType"));
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((NameType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_NameType_type") :
-			getString("_UI_NameType_type") + " " + label;
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(NameType.class)) {
-			case FacesConfigPackage.NAME_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.NAME_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/NavigationCaseTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/NavigationCaseTypeItemProvider.java
deleted file mode 100644
index 1247a1b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/NavigationCaseTypeItemProvider.java
+++ /dev/null
@@ -1,282 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType;
-import org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class NavigationCaseTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NavigationCaseTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_NavigationCaseType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_NavigationCaseType_id_feature", "_UI_NavigationCaseType_type"),
-				 FacesConfigPackage.Literals.NAVIGATION_CASE_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.NAVIGATION_CASE_TYPE__DESCRIPTION);
-			childrenFeatures.add(FacesConfigPackage.Literals.NAVIGATION_CASE_TYPE__DISPLAY_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.NAVIGATION_CASE_TYPE__ICON);
-			childrenFeatures.add(FacesConfigPackage.Literals.NAVIGATION_CASE_TYPE__FROM_ACTION);
-			childrenFeatures.add(FacesConfigPackage.Literals.NAVIGATION_CASE_TYPE__FROM_OUTCOME);
-			childrenFeatures.add(FacesConfigPackage.Literals.NAVIGATION_CASE_TYPE__IF);
-			childrenFeatures.add(FacesConfigPackage.Literals.NAVIGATION_CASE_TYPE__TO_VIEW_ID);
-			childrenFeatures.add(FacesConfigPackage.Literals.NAVIGATION_CASE_TYPE__REDIRECT);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 NavigationCaseType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/NavigationCaseType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((NavigationCaseType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_NavigationCaseType_type") :
-			getString("_UI_NavigationCaseType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(NavigationCaseType.class)) {
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__DESCRIPTION:
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__DISPLAY_NAME:
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__ICON:
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__FROM_ACTION:
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__FROM_OUTCOME:
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__IF:
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__TO_VIEW_ID:
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__REDIRECT:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.NAVIGATION_CASE_TYPE__DESCRIPTION,
-				 FacesConfigFactory.eINSTANCE.createDescriptionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.NAVIGATION_CASE_TYPE__DISPLAY_NAME,
-				 FacesConfigFactory.eINSTANCE.createDisplayNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.NAVIGATION_CASE_TYPE__ICON,
-				 FacesConfigFactory.eINSTANCE.createIconType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.NAVIGATION_CASE_TYPE__FROM_ACTION,
-				 FacesConfigFactory.eINSTANCE.createFromActionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.NAVIGATION_CASE_TYPE__FROM_OUTCOME,
-				 FacesConfigFactory.eINSTANCE.createFromOutcomeType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.NAVIGATION_CASE_TYPE__IF,
-				 FacesConfigFactory.eINSTANCE.createIfType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.NAVIGATION_CASE_TYPE__TO_VIEW_ID,
-				 FacesConfigFactory.eINSTANCE.createToViewIdType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.NAVIGATION_CASE_TYPE__REDIRECT,
-				 FacesConfigFactory.eINSTANCE.createRedirectType()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		NavigationCaseType navigationcase = (NavigationCaseType) object;
-		switch (columnIndex) {
-
-		case 0:
-			return ((NavigationRuleType) navigationcase.eContainer())
-					.getFromViewId() == null ? "" //$NON-NLS-1$
-					: ((NavigationRuleType) navigationcase.eContainer())
-							.getFromViewId().getTextContent();
-		case 1:
-			return navigationcase.getFromOutcome() == null ? "" : navigationcase //$NON-NLS-1$
-					.getFromOutcome().getTextContent();
-		case 2:
-			return navigationcase.getToViewId() == null ? "" : navigationcase //$NON-NLS-1$
-					.getToViewId().getTextContent();
-		}
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/NavigationHandlerTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/NavigationHandlerTypeItemProvider.java
deleted file mode 100644
index c61240b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/NavigationHandlerTypeItemProvider.java
+++ /dev/null
@@ -1,209 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.NavigationHandlerType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.NavigationHandlerType} object.
- * <!-- begin-user-doc --> 
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class NavigationHandlerTypeItemProvider extends ItemProviderAdapter
-		implements IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc --> 
-	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NavigationHandlerTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc --> 
-	 * @param object
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_NavigationHandlerType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_NavigationHandlerType_textContent_feature", "_UI_NavigationHandlerType_type"),
-				 FacesConfigPackage.Literals.NAVIGATION_HANDLER_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc --> 
-     * @param object
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_NavigationHandlerType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_NavigationHandlerType_id_feature", "_UI_NavigationHandlerType_type"),
-				 FacesConfigPackage.Literals.NAVIGATION_HANDLER_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns NavigationHandlerType.gif.
-	 * <!-- begin-user-doc --> <!--
-	 * end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/NavigationHandlerType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc
-	 * --> <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((NavigationHandlerType) object).getTextContent();
-		return label == null || label.length() == 0 ? getString("_UI_NavigationHandlerType_type")
-				: label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(NavigationHandlerType.class)) {
-			case FacesConfigPackage.NAVIGATION_HANDLER_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.NAVIGATION_HANDLER_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_NavigationHandlerType_type"); //$NON-NLS-1$
-		}
-
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/NavigationRuleExtensionTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/NavigationRuleExtensionTypeItemProvider.java
deleted file mode 100644
index 5570808..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/NavigationRuleExtensionTypeItemProvider.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.edit.provider.IEditingDomainItemProvider;
-import org.eclipse.emf.edit.provider.IItemLabelProvider;
-import org.eclipse.emf.edit.provider.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleExtensionType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleExtensionType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public class NavigationRuleExtensionTypeItemProvider
-    extends ExtensionTypeItemProvider
-    implements	
-        IEditingDomainItemProvider,	
-        IStructuredItemContentProvider,	
-        ITreeItemContentProvider,	
-        IItemLabelProvider,	
-        IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    @SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NavigationRuleExtensionTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This returns NavigationRuleExtensionType.gif.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-    public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/NavigationRuleExtensionType")); //$NON-NLS-1$
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-    public String getText(Object object) {
-		String label = ((NavigationRuleExtensionType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_NavigationRuleExtensionType_type") : //$NON-NLS-1$
-			getString("_UI_NavigationRuleExtensionType_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
-	 */
-    public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-		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
-	 */
-    protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/NavigationRuleTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/NavigationRuleTypeItemProvider.java
deleted file mode 100644
index 485aee4..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/NavigationRuleTypeItemProvider.java
+++ /dev/null
@@ -1,254 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class NavigationRuleTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider{
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NavigationRuleTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_NavigationRuleType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_NavigationRuleType_id_feature", "_UI_NavigationRuleType_type"),
-				 FacesConfigPackage.Literals.NAVIGATION_RULE_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.NAVIGATION_RULE_TYPE__DESCRIPTION);
-			childrenFeatures.add(FacesConfigPackage.Literals.NAVIGATION_RULE_TYPE__DISPLAY_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.NAVIGATION_RULE_TYPE__ICON);
-			childrenFeatures.add(FacesConfigPackage.Literals.NAVIGATION_RULE_TYPE__FROM_VIEW_ID);
-			childrenFeatures.add(FacesConfigPackage.Literals.NAVIGATION_RULE_TYPE__NAVIGATION_CASE);
-			childrenFeatures.add(FacesConfigPackage.Literals.NAVIGATION_RULE_TYPE__NAVIGATION_RULE_EXTENSION);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 NavigationRuleType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/NavigationRuleType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((NavigationRuleType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_NavigationRuleType_type") :
-			getString("_UI_NavigationRuleType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(NavigationRuleType.class)) {
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__DESCRIPTION:
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__DISPLAY_NAME:
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__ICON:
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__FROM_VIEW_ID:
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__NAVIGATION_CASE:
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__NAVIGATION_RULE_EXTENSION:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.NAVIGATION_RULE_TYPE__DESCRIPTION,
-				 FacesConfigFactory.eINSTANCE.createDescriptionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.NAVIGATION_RULE_TYPE__DISPLAY_NAME,
-				 FacesConfigFactory.eINSTANCE.createDisplayNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.NAVIGATION_RULE_TYPE__ICON,
-				 FacesConfigFactory.eINSTANCE.createIconType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.NAVIGATION_RULE_TYPE__FROM_VIEW_ID,
-				 FacesConfigFactory.eINSTANCE.createFromViewIdType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.NAVIGATION_RULE_TYPE__NAVIGATION_CASE,
-				 FacesConfigFactory.eINSTANCE.createNavigationCaseType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.NAVIGATION_RULE_TYPE__NAVIGATION_RULE_EXTENSION,
-				 FacesConfigFactory.eINSTANCE.createNavigationRuleExtensionType()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		// TODO Auto-generated method stub
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/NullValueTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/NullValueTypeItemProvider.java
deleted file mode 100644
index 7ce6233..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/NullValueTypeItemProvider.java
+++ /dev/null
@@ -1,173 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.NullValueType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.NullValueType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class NullValueTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NullValueTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_NullValueType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_NullValueType_id_feature", "_UI_NullValueType_type"),
-				 FacesConfigPackage.Literals.NULL_VALUE_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns NullValueType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/NullValueType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((NullValueType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_NullValueType_type") :
-			getString("_UI_NullValueType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(NullValueType.class)) {
-			case FacesConfigPackage.NULL_VALUE_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	public String getColumnText(Object object, int columnIndex) {
-		return "<null-value>"; //$NON-NLS-1$
-	}
-
-	public Object getColumnImage(Object object, int columnIndex) {
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/OrderingOrderingTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/OrderingOrderingTypeItemProvider.java
deleted file mode 100644
index d351827..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/OrderingOrderingTypeItemProvider.java
+++ /dev/null
@@ -1,179 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.emf.edit.provider.ItemProviderAdapter;
-import org.eclipse.emf.edit.provider.ViewerNotification;
-import org.eclipse.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.OrderingOrderingType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.OrderingOrderingType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public class OrderingOrderingTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory
-	 * <!-- end-user-doc --> 
-	 * @generated
-	 */
-	public OrderingOrderingTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.ORDERING_ORDERING_TYPE__NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.ORDERING_ORDERING_TYPE__OTHERS);
-		}
-		return childrenFeatures;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 OrderingOrderingType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/OrderingOrderingType")); //$NON-NLS-1$
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		return getString("_UI_OrderingOrderingType_type"); //$NON-NLS-1$
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(OrderingOrderingType.class)) {
-			case FacesConfigPackage.ORDERING_ORDERING_TYPE__NAME:
-			case FacesConfigPackage.ORDERING_ORDERING_TYPE__OTHERS:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.ORDERING_ORDERING_TYPE__NAME,
-				 FacesConfigFactory.eINSTANCE.createNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.ORDERING_ORDERING_TYPE__OTHERS,
-				 FacesConfigFactory.eINSTANCE.createOrderingOthersType()));
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/OrderingOthersTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/OrderingOthersTypeItemProvider.java
deleted file mode 100644
index 4790f6b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/OrderingOthersTypeItemProvider.java
+++ /dev/null
@@ -1,167 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.OrderingOthersType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.OrderingOthersType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class OrderingOthersTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory
-	 * <!-- end-user-doc --> 
-	 * @generated
-	 */
-	public OrderingOthersTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_OrderingOthersType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_OrderingOthersType_id_feature", "_UI_OrderingOthersType_type"),
-				 FacesConfigPackage.Literals.ORDERING_OTHERS_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This returns OrderingOthersType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/OrderingOthersType"));
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((OrderingOthersType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_OrderingOthersType_type") :
-			getString("_UI_OrderingOthersType_type") + " " + label;
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(OrderingOthersType.class)) {
-			case FacesConfigPackage.ORDERING_OTHERS_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/OrderingTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/OrderingTypeItemProvider.java
deleted file mode 100644
index 5e21cd1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/OrderingTypeItemProvider.java
+++ /dev/null
@@ -1,201 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.emf.edit.provider.ItemProviderAdapter;
-import org.eclipse.emf.edit.provider.ViewerNotification;
-import org.eclipse.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.OrderingType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.OrderingType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public class OrderingTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public OrderingTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.ORDERING_TYPE__BEFORE);
-			childrenFeatures.add(FacesConfigPackage.Literals.ORDERING_TYPE__AFTER);
-		}
-		return childrenFeatures;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 OrderingType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/OrderingType")); //$NON-NLS-1$
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		return getString("_UI_OrderingType_type"); //$NON-NLS-1$
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(OrderingType.class)) {
-			case FacesConfigPackage.ORDERING_TYPE__BEFORE:
-			case FacesConfigPackage.ORDERING_TYPE__AFTER:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.ORDERING_TYPE__BEFORE,
-				 FacesConfigFactory.eINSTANCE.createOrderingOrderingType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.ORDERING_TYPE__AFTER,
-				 FacesConfigFactory.eINSTANCE.createOrderingOrderingType()));
-	}
-
-	/**
-	 * This returns the label text for {@link org.eclipse.emf.edit.command.CreateChildCommand}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getCreateChildText(Object owner, Object feature, Object child, Collection selection) {
-		Object childFeature = feature;
-		Object childObject = child;
-
-		boolean qualify =
-			childFeature == FacesConfigPackage.Literals.ORDERING_TYPE__BEFORE ||
-			childFeature == FacesConfigPackage.Literals.ORDERING_TYPE__AFTER;
-
-		if (qualify) {
-			return getString
-				("_UI_CreateChild_text2", //$NON-NLS-1$
-				 new Object[] { getTypeText(childObject), getFeatureText(childFeature), getTypeText(owner) });
-		}
-		return super.getCreateChildText(owner, feature, child, selection);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/PartialViewContextFactoryTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/PartialViewContextFactoryTypeItemProvider.java
deleted file mode 100644
index 228d214..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/PartialViewContextFactoryTypeItemProvider.java
+++ /dev/null
@@ -1,216 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.PartialViewContextFactoryType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.PartialViewContextFactoryType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class PartialViewContextFactoryTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource,
-		ITableItemLabelProvider{
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PartialViewContextFactoryTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc -->	 
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_PartialViewContextFactoryType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_PartialViewContextFactoryType_textContent_feature", "_UI_PartialViewContextFactoryType_type"),
-				 FacesConfigPackage.Literals.PARTIAL_VIEW_CONTEXT_FACTORY_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_PartialViewContextFactoryType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_PartialViewContextFactoryType_id_feature", "_UI_PartialViewContextFactoryType_type"),
-				 FacesConfigPackage.Literals.PARTIAL_VIEW_CONTEXT_FACTORY_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This returns PartialViewContextFactoryType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/PartialViewContextFactoryType"));
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((PartialViewContextFactoryType) object).getTextContent();
-		return label == null || label.length() == 0 ? getString("_UI_PartialViewContextFactoryType_type")
-				: label;
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(PartialViewContextFactoryType.class)) {
-			case FacesConfigPackage.PARTIAL_VIEW_CONTEXT_FACTORY_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.PARTIAL_VIEW_CONTEXT_FACTORY_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		// TODO Auto-generated method stub
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_PartialViewContextFactoryType_type"); //$NON-NLS-1$
-		}
-		return null;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/PhaseListenerTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/PhaseListenerTypeItemProvider.java
deleted file mode 100644
index 9eec941..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/PhaseListenerTypeItemProvider.java
+++ /dev/null
@@ -1,210 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.PhaseListenerType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.PhaseListenerType} object.
- * <!-- begin-user-doc --> 
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class PhaseListenerTypeItemProvider extends ItemProviderAdapter
-		implements IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc --> 
- 	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PhaseListenerTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc --> 
- 	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_PhaseListenerType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_PhaseListenerType_textContent_feature", "_UI_PhaseListenerType_type"),
-				 FacesConfigPackage.Literals.PHASE_LISTENER_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc --> 
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_PhaseListenerType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_PhaseListenerType_id_feature", "_UI_PhaseListenerType_type"),
-				 FacesConfigPackage.Literals.PHASE_LISTENER_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns PhaseListenerType.gif.
-	 * <!-- begin-user-doc --> <!--
-	 * end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/PhaseListenerType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc
-	 * --> <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((PhaseListenerType) object).getTextContent();
-		return label == null || label.length() == 0 ? getString("_UI_PhaseListenerType_type")
-				: label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(PhaseListenerType.class)) {
-			case FacesConfigPackage.PHASE_LISTENER_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.PHASE_LISTENER_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-
-		switch (columnIndex) {
-
-			case 0:
-				return getText(object);
-			case 1:
-				return getString("_UI_ActionListenerType_type"); //$NON-NLS-1$
-			}
-
-			return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/PropertyClassTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/PropertyClassTypeItemProvider.java
deleted file mode 100644
index c58a1f5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/PropertyClassTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.PropertyClassType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.PropertyClassType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class PropertyClassTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PropertyClassTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_PropertyClassType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_PropertyClassType_textContent_feature", "_UI_PropertyClassType_type"),
-				 FacesConfigPackage.Literals.PROPERTY_CLASS_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_PropertyClassType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_PropertyClassType_id_feature", "_UI_PropertyClassType_type"),
-				 FacesConfigPackage.Literals.PROPERTY_CLASS_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns PropertyClassType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/PropertyClassType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((PropertyClassType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_PropertyClassType_type") :
-			getString("_UI_PropertyClassType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(PropertyClassType.class)) {
-			case FacesConfigPackage.PROPERTY_CLASS_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.PROPERTY_CLASS_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/PropertyExtensionTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/PropertyExtensionTypeItemProvider.java
deleted file mode 100644
index 6ee9752..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/PropertyExtensionTypeItemProvider.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.edit.provider.IEditingDomainItemProvider;
-import org.eclipse.emf.edit.provider.IItemLabelProvider;
-import org.eclipse.emf.edit.provider.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.jst.jsf.facesconfig.emf.PropertyExtensionType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.PropertyExtensionType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public class PropertyExtensionTypeItemProvider
-	extends ExtensionTypeItemProvider
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PropertyExtensionTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This returns PropertyExtensionType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/PropertyExtensionType")); //$NON-NLS-1$
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((PropertyExtensionType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_PropertyExtensionType_type") : //$NON-NLS-1$
-			getString("_UI_PropertyExtensionType_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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-		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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/PropertyNameTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/PropertyNameTypeItemProvider.java
deleted file mode 100644
index 708ac34..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/PropertyNameTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.PropertyNameType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.PropertyNameType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class PropertyNameTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PropertyNameTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_PropertyNameType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_PropertyNameType_textContent_feature", "_UI_PropertyNameType_type"),
-				 FacesConfigPackage.Literals.PROPERTY_NAME_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_PropertyNameType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_PropertyNameType_id_feature", "_UI_PropertyNameType_type"),
-				 FacesConfigPackage.Literals.PROPERTY_NAME_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns PropertyNameType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/PropertyNameType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((PropertyNameType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_PropertyNameType_type") :
-			getString("_UI_PropertyNameType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(PropertyNameType.class)) {
-			case FacesConfigPackage.PROPERTY_NAME_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.PROPERTY_NAME_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/PropertyResolverTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/PropertyResolverTypeItemProvider.java
deleted file mode 100644
index e26873d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/PropertyResolverTypeItemProvider.java
+++ /dev/null
@@ -1,210 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.PropertyResolverType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.PropertyResolverType} object.
- * <!-- begin-user-doc --> 
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class PropertyResolverTypeItemProvider extends ItemProviderAdapter
-		implements IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc --> 
-	 * @param adapterFactory
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PropertyResolverTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc --> 
-	 * @param object
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_PropertyResolverType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_PropertyResolverType_textContent_feature", "_UI_PropertyResolverType_type"),
-				 FacesConfigPackage.Literals.PROPERTY_RESOLVER_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc--> 
-     * @param object
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_PropertyResolverType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_PropertyResolverType_id_feature", "_UI_PropertyResolverType_type"),
-				 FacesConfigPackage.Literals.PROPERTY_RESOLVER_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns PropertyResolverType.gif.
-	 * <!-- begin-user-doc --> <!--
-	 * end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/PropertyResolverType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc
-	 * --> <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((PropertyResolverType) object).getTextContent();
-		return label == null || label.length() == 0 ? getString("_UI_PropertyResolverType_type")
-				: label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(PropertyResolverType.class)) {
-			case FacesConfigPackage.PROPERTY_RESOLVER_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.PROPERTY_RESOLVER_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		// TODO Auto-generated method stub
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_PropertyResolverType_type"); //$NON-NLS-1$
-		}
-
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/PropertyTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/PropertyTypeItemProvider.java
deleted file mode 100644
index c635925..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/PropertyTypeItemProvider.java
+++ /dev/null
@@ -1,282 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.PropertyType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * 
- * @gemerated
- */
-public class PropertyTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource, 
-		ITableItemLabelProvider{
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PropertyTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_PropertyType_id_feature"), //$NON-NLS-1$
-				 getString("_UI_PropertyDescriptor_description", "_UI_PropertyType_id_feature", "_UI_PropertyType_type"),  //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
-				 FacesConfigPackage.Literals.PROPERTY_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.PROPERTY_TYPE__DESCRIPTION);
-			childrenFeatures.add(FacesConfigPackage.Literals.PROPERTY_TYPE__DISPLAY_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.PROPERTY_TYPE__ICON);
-			childrenFeatures.add(FacesConfigPackage.Literals.PROPERTY_TYPE__PROPERTY_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.PROPERTY_TYPE__PROPERTY_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.PROPERTY_TYPE__DEFAULT_VALUE);
-			childrenFeatures.add(FacesConfigPackage.Literals.PROPERTY_TYPE__SUGGESTED_VALUE);
-			childrenFeatures.add(FacesConfigPackage.Literals.PROPERTY_TYPE__PROPERTY_EXTENSION);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 PropertyType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/PropertyType")); //$NON-NLS-1$
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((PropertyType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_PropertyType_type") : //$NON-NLS-1$
-			getString("_UI_PropertyType_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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(PropertyType.class)) {
-			case FacesConfigPackage.PROPERTY_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.PROPERTY_TYPE__DESCRIPTION:
-			case FacesConfigPackage.PROPERTY_TYPE__DISPLAY_NAME:
-			case FacesConfigPackage.PROPERTY_TYPE__ICON:
-			case FacesConfigPackage.PROPERTY_TYPE__PROPERTY_NAME:
-			case FacesConfigPackage.PROPERTY_TYPE__PROPERTY_CLASS:
-			case FacesConfigPackage.PROPERTY_TYPE__DEFAULT_VALUE:
-			case FacesConfigPackage.PROPERTY_TYPE__SUGGESTED_VALUE:
-			case FacesConfigPackage.PROPERTY_TYPE__PROPERTY_EXTENSION:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.PROPERTY_TYPE__DESCRIPTION,
-				 FacesConfigFactory.eINSTANCE.createDescriptionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.PROPERTY_TYPE__DISPLAY_NAME,
-				 FacesConfigFactory.eINSTANCE.createDisplayNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.PROPERTY_TYPE__ICON,
-				 FacesConfigFactory.eINSTANCE.createIconType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.PROPERTY_TYPE__PROPERTY_NAME,
-				 FacesConfigFactory.eINSTANCE.createPropertyNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.PROPERTY_TYPE__PROPERTY_CLASS,
-				 FacesConfigFactory.eINSTANCE.createPropertyClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.PROPERTY_TYPE__DEFAULT_VALUE,
-				 FacesConfigFactory.eINSTANCE.createDefaultValueType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.PROPERTY_TYPE__SUGGESTED_VALUE,
-				 FacesConfigFactory.eINSTANCE.createSuggestedValueType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.PROPERTY_TYPE__PROPERTY_EXTENSION,
-				 FacesConfigFactory.eINSTANCE.createPropertyExtensionType()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	public String getColumnText(Object object, int columnIndex) {
-		PropertyType property = (PropertyType) object;
-		switch (columnIndex) {
-
-		case 0:
-			return property.getPropertyName() == null ? "" : property //$NON-NLS-1$
-					.getPropertyName().getTextContent();
-		case 1:
-			return property.getPropertyClass() == null ? "" : property //$NON-NLS-1$
-					.getPropertyClass().getTextContent();
-		case 2:
-			return property.getDefaultValue() == null ? "" : property //$NON-NLS-1$
-					.getDefaultValue().getTextContent();
-		case 3:
-			return property.getSuggestedValue() == null ? "" : property //$NON-NLS-1$
-					.getSuggestedValue().getTextContent();
-		}
-		return null;
-	}
-
-	public Object getColumnImage(Object object, int columnIndex) {
-		// TODO Auto-generated method stub
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RedirectTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RedirectTypeItemProvider.java
deleted file mode 100644
index b2599d7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RedirectTypeItemProvider.java
+++ /dev/null
@@ -1,230 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.RedirectType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RedirectType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class RedirectTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RedirectTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-			addIncludeViewParamsPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_RedirectType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_RedirectType_id_feature", "_UI_RedirectType_type"),
-				 FacesConfigPackage.Literals.REDIRECT_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Include View Params feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIncludeViewParamsPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_RedirectType_includeViewParams_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_RedirectType_includeViewParams_feature", "_UI_RedirectType_type"),
-				 FacesConfigPackage.Literals.REDIRECT_TYPE__INCLUDE_VIEW_PARAMS,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-				/**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.REDIRECT_TYPE__VIEW_PARAM);
-		}
-		return childrenFeatures;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 RedirectType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/RedirectType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((RedirectType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_RedirectType_type") :
-			getString("_UI_RedirectType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(RedirectType.class)) {
-			case FacesConfigPackage.REDIRECT_TYPE__ID:
-			case FacesConfigPackage.REDIRECT_TYPE__INCLUDE_VIEW_PARAMS:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.REDIRECT_TYPE__VIEW_PARAM:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.REDIRECT_TYPE__VIEW_PARAM,
-				 FacesConfigFactory.eINSTANCE.createRedirectViewParamType()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RedirectViewParamTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RedirectViewParamTypeItemProvider.java
deleted file mode 100644
index 83ebec0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RedirectViewParamTypeItemProvider.java
+++ /dev/null
@@ -1,212 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class RedirectViewParamTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RedirectViewParamTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_RedirectViewParamType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_RedirectViewParamType_id_feature", "_UI_RedirectViewParamType_type"),
-				 FacesConfigPackage.Literals.REDIRECT_VIEW_PARAM_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.REDIRECT_VIEW_PARAM_TYPE__NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.REDIRECT_VIEW_PARAM_TYPE__VALUE);
-		}
-		return childrenFeatures;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 RedirectViewParamType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/RedirectViewParamType"));
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((RedirectViewParamType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_RedirectViewParamType_type") :
-			getString("_UI_RedirectViewParamType_type") + " " + label;
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(RedirectViewParamType.class)) {
-			case FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__NAME:
-			case FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__VALUE:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.REDIRECT_VIEW_PARAM_TYPE__NAME,
-				 FacesConfigFactory.eINSTANCE.createNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.REDIRECT_VIEW_PARAM_TYPE__VALUE,
-				 FacesConfigFactory.eINSTANCE.createValueType()));
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ReferencedBeanClassTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ReferencedBeanClassTypeItemProvider.java
deleted file mode 100644
index 36aa462..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ReferencedBeanClassTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanClassType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanClassType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ReferencedBeanClassTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ReferencedBeanClassTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ReferencedBeanClassType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ReferencedBeanClassType_textContent_feature", "_UI_ReferencedBeanClassType_type"),
-				 FacesConfigPackage.Literals.REFERENCED_BEAN_CLASS_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ReferencedBeanClassType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ReferencedBeanClassType_id_feature", "_UI_ReferencedBeanClassType_type"),
-				 FacesConfigPackage.Literals.REFERENCED_BEAN_CLASS_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns ReferencedBeanClassType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ReferencedBeanClassType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((ReferencedBeanClassType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ReferencedBeanClassType_type") :
-			getString("_UI_ReferencedBeanClassType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ReferencedBeanClassType.class)) {
-			case FacesConfigPackage.REFERENCED_BEAN_CLASS_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.REFERENCED_BEAN_CLASS_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ReferencedBeanNameTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ReferencedBeanNameTypeItemProvider.java
deleted file mode 100644
index 5709669..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ReferencedBeanNameTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanNameType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanNameType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ReferencedBeanNameTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ReferencedBeanNameTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ReferencedBeanNameType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ReferencedBeanNameType_textContent_feature", "_UI_ReferencedBeanNameType_type"),
-				 FacesConfigPackage.Literals.REFERENCED_BEAN_NAME_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ReferencedBeanNameType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ReferencedBeanNameType_id_feature", "_UI_ReferencedBeanNameType_type"),
-				 FacesConfigPackage.Literals.REFERENCED_BEAN_NAME_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns ReferencedBeanNameType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ReferencedBeanNameType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((ReferencedBeanNameType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ReferencedBeanNameType_type") :
-			getString("_UI_ReferencedBeanNameType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ReferencedBeanNameType.class)) {
-			case FacesConfigPackage.REFERENCED_BEAN_NAME_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.REFERENCED_BEAN_NAME_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ReferencedBeanTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ReferencedBeanTypeItemProvider.java
deleted file mode 100644
index 8ca747c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ReferencedBeanTypeItemProvider.java
+++ /dev/null
@@ -1,233 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ReferencedBeanTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ReferencedBeanTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ReferencedBeanType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ReferencedBeanType_id_feature", "_UI_ReferencedBeanType_type"),
-				 FacesConfigPackage.Literals.REFERENCED_BEAN_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.REFERENCED_BEAN_TYPE__DESCRIPTION);
-			childrenFeatures.add(FacesConfigPackage.Literals.REFERENCED_BEAN_TYPE__DISPLAY_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.REFERENCED_BEAN_TYPE__ICON);
-			childrenFeatures.add(FacesConfigPackage.Literals.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_CLASS);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 ReferencedBeanType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ReferencedBeanType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((ReferencedBeanType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ReferencedBeanType_type") :
-			getString("_UI_ReferencedBeanType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ReferencedBeanType.class)) {
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__DESCRIPTION:
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__DISPLAY_NAME:
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__ICON:
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_NAME:
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_CLASS:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.REFERENCED_BEAN_TYPE__DESCRIPTION,
-				 FacesConfigFactory.eINSTANCE.createDescriptionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.REFERENCED_BEAN_TYPE__DISPLAY_NAME,
-				 FacesConfigFactory.eINSTANCE.createDisplayNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.REFERENCED_BEAN_TYPE__ICON,
-				 FacesConfigFactory.eINSTANCE.createIconType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_NAME,
-				 FacesConfigFactory.eINSTANCE.createReferencedBeanNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_CLASS,
-				 FacesConfigFactory.eINSTANCE.createReferencedBeanClassType()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RenderKitClassTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RenderKitClassTypeItemProvider.java
deleted file mode 100644
index d13060b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RenderKitClassTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.RenderKitClassType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitClassType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class RenderKitClassTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RenderKitClassTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_RenderKitClassType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_RenderKitClassType_textContent_feature", "_UI_RenderKitClassType_type"),
-				 FacesConfigPackage.Literals.RENDER_KIT_CLASS_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_RenderKitClassType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_RenderKitClassType_id_feature", "_UI_RenderKitClassType_type"),
-				 FacesConfigPackage.Literals.RENDER_KIT_CLASS_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns RenderKitClassType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/RenderKitClassType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((RenderKitClassType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_RenderKitClassType_type") :
-			getString("_UI_RenderKitClassType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(RenderKitClassType.class)) {
-			case FacesConfigPackage.RENDER_KIT_CLASS_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.RENDER_KIT_CLASS_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RenderKitExtensionTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RenderKitExtensionTypeItemProvider.java
deleted file mode 100644
index 359661f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RenderKitExtensionTypeItemProvider.java
+++ /dev/null
@@ -1,121 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.edit.provider.IEditingDomainItemProvider;
-import org.eclipse.emf.edit.provider.IItemLabelProvider;
-import org.eclipse.emf.edit.provider.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.jst.jsf.facesconfig.emf.RenderKitExtensionType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitExtensionType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class RenderKitExtensionTypeItemProvider
-    extends ExtensionTypeItemProvider
-    implements	
-        IEditingDomainItemProvider,	
-        IStructuredItemContentProvider,	
-        ITreeItemContentProvider,	
-        IItemLabelProvider,	
-        IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    @SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public RenderKitExtensionTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This returns RenderKitExtensionType.gif.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/RenderKitExtensionType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getText(Object object) {
-		String label = ((RenderKitExtensionType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_RenderKitExtensionType_type") :
-			getString("_UI_RenderKitExtensionType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-    public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-		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
-	 */
-    protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RenderKitFactoryTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RenderKitFactoryTypeItemProvider.java
deleted file mode 100644
index 804431a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RenderKitFactoryTypeItemProvider.java
+++ /dev/null
@@ -1,210 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.RenderKitFactoryType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitFactoryType} object.
- * <!-- begin-user-doc --> 
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class RenderKitFactoryTypeItemProvider extends ItemProviderAdapter
-		implements IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc --> 
-	 * @param adapterFactory
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RenderKitFactoryTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc --> 
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_RenderKitFactoryType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_RenderKitFactoryType_textContent_feature", "_UI_RenderKitFactoryType_type"),
-				 FacesConfigPackage.Literals.RENDER_KIT_FACTORY_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc --> 
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_RenderKitFactoryType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_RenderKitFactoryType_id_feature", "_UI_RenderKitFactoryType_type"),
-				 FacesConfigPackage.Literals.RENDER_KIT_FACTORY_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns RenderKitFactoryType.gif.
-	 * <!-- begin-user-doc --> <!--
-	 * end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/RenderKitFactoryType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc
-	 * --> <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((RenderKitFactoryType) object).getTextContent();
-		return label == null || label.length() == 0 ? getString("_UI_RenderKitFactoryType_type")
-				: label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(RenderKitFactoryType.class)) {
-			case FacesConfigPackage.RENDER_KIT_FACTORY_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.RENDER_KIT_FACTORY_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-
-		switch (columnIndex) {
-
-			case 0:
-				return getText(object);
-			case 1:
-				return getString("_UI_RenderKitFactoryType_type"); //$NON-NLS-1$
-			}
-
-			return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RenderKitIdTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RenderKitIdTypeItemProvider.java
deleted file mode 100644
index 4f96da3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RenderKitIdTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.RenderKitIdType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitIdType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class RenderKitIdTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RenderKitIdTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_RenderKitIdType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_RenderKitIdType_textContent_feature", "_UI_RenderKitIdType_type"),
-				 FacesConfigPackage.Literals.RENDER_KIT_ID_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_RenderKitIdType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_RenderKitIdType_id_feature", "_UI_RenderKitIdType_type"),
-				 FacesConfigPackage.Literals.RENDER_KIT_ID_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns RenderKitIdType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/RenderKitIdType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((RenderKitIdType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_RenderKitIdType_type") :
-			getString("_UI_RenderKitIdType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(RenderKitIdType.class)) {
-			case FacesConfigPackage.RENDER_KIT_ID_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.RENDER_KIT_ID_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RenderKitTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RenderKitTypeItemProvider.java
deleted file mode 100644
index 560e7a1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RenderKitTypeItemProvider.java
+++ /dev/null
@@ -1,303 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.RenderKitType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType} object.
- * <!-- begin-user-doc --> 
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class RenderKitTypeItemProvider extends ItemProviderAdapter implements
-		IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc --> 
-	 * @param adapterFactory
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RenderKitTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc --> 
-     * @param object
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_RenderKitType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_RenderKitType_id_feature", "_UI_RenderKitType_type"),
-				 FacesConfigPackage.Literals.RENDER_KIT_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.RENDER_KIT_TYPE__DESCRIPTION);
-			childrenFeatures.add(FacesConfigPackage.Literals.RENDER_KIT_TYPE__DISPLAY_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.RENDER_KIT_TYPE__ICON);
-			childrenFeatures.add(FacesConfigPackage.Literals.RENDER_KIT_TYPE__RENDER_KIT_ID);
-			childrenFeatures.add(FacesConfigPackage.Literals.RENDER_KIT_TYPE__RENDER_KIT_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.RENDER_KIT_TYPE__RENDERER);
-			childrenFeatures.add(FacesConfigPackage.Literals.RENDER_KIT_TYPE__CLIENT_BEHAVIOR_RENDERER);
-			childrenFeatures.add(FacesConfigPackage.Literals.RENDER_KIT_TYPE__RENDER_KIT_EXTENSION);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 RenderKitType.gif. <!-- begin-user-doc --> <!-- end-user-doc
-	 * -->
-	 * 
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/RenderKitType"));
-	}
-
-	/**
-	 * This returns the label text for the adapted class. <!-- begin-user-doc
-	 * --> <!-- end-user-doc -->
-	 * 
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-
-		String label = null;
-		
-		if (((RenderKitType) object).getDisplayName() != null
-				&& ((RenderKitType) object).getDisplayName().size() > 0) {
-			label = ((DisplayNameType) ((RenderKitType) object)
-					.getDisplayName().get(0)).getTextContent();
-		}
-
-		if ((label == null || label.length() == 0) && ((RenderKitType) object).getRenderKitId() != null
-				&& ((RenderKitType) object).getRenderKitId().getTextContent() != null) {
-			label = ((RenderKitType) object).getRenderKitId().getTextContent();
-		}
-
-		if (label == null || label.length() == 0) {
-			if (((RenderKitType) object).getRenderKitClass() != null)
-				label = ((RenderKitType) object).getRenderKitClass()
-						.getTextContent();
-		}
-		
-		if (label == null || label.length() == 0) {
-			label = ((RenderKitType) object).getId();
-		}
-
-		return label == null || label.length() == 0 ? getString("_UI_RenderKitType_type")
-				: label;
-//				: getString("_UI_RenderKitType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(RenderKitType.class)) {
-			case FacesConfigPackage.RENDER_KIT_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.RENDER_KIT_TYPE__DESCRIPTION:
-			case FacesConfigPackage.RENDER_KIT_TYPE__DISPLAY_NAME:
-			case FacesConfigPackage.RENDER_KIT_TYPE__ICON:
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_ID:
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_CLASS:
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDERER:
-			case FacesConfigPackage.RENDER_KIT_TYPE__CLIENT_BEHAVIOR_RENDERER:
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_EXTENSION:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.RENDER_KIT_TYPE__DESCRIPTION,
-				 FacesConfigFactory.eINSTANCE.createDescriptionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.RENDER_KIT_TYPE__DISPLAY_NAME,
-				 FacesConfigFactory.eINSTANCE.createDisplayNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.RENDER_KIT_TYPE__ICON,
-				 FacesConfigFactory.eINSTANCE.createIconType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.RENDER_KIT_TYPE__RENDER_KIT_ID,
-				 FacesConfigFactory.eINSTANCE.createRenderKitIdType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.RENDER_KIT_TYPE__RENDER_KIT_CLASS,
-				 FacesConfigFactory.eINSTANCE.createRenderKitClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.RENDER_KIT_TYPE__RENDERER,
-				 FacesConfigFactory.eINSTANCE.createRendererType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.RENDER_KIT_TYPE__CLIENT_BEHAVIOR_RENDERER,
-				 FacesConfigFactory.eINSTANCE.createClientBehaviorRendererType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.RENDER_KIT_TYPE__RENDER_KIT_EXTENSION,
-				 FacesConfigFactory.eINSTANCE.createRenderKitExtensionType()));
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		// TODO Auto-generated method stub
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-//		RenderKitType renderkit = (RenderKitType) object;
-//		switch (columnIndex) {
-//		case 0:
-//			return getText(object);
-//		case 1:
-//			return renderkit.getRenderKitClass() == null ? "" : renderkit //$NON-NLS-1$
-//					.getRenderKitClass().getTextContent();
-//		}
-//		return null;
-//		RenderKitType renderkit = (RenderKitType) object;
-		switch (columnIndex) {
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_RenderKitType_type"); //$NON-NLS-1$
-		}
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RendererClassTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RendererClassTypeItemProvider.java
deleted file mode 100644
index 77eabbe..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RendererClassTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.RendererClassType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RendererClassType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class RendererClassTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RendererClassTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_RendererClassType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_RendererClassType_textContent_feature", "_UI_RendererClassType_type"),
-				 FacesConfigPackage.Literals.RENDERER_CLASS_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_RendererClassType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_RendererClassType_id_feature", "_UI_RendererClassType_type"),
-				 FacesConfigPackage.Literals.RENDERER_CLASS_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns RendererClassType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/RendererClassType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((RendererClassType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_RendererClassType_type") :
-			getString("_UI_RendererClassType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(RendererClassType.class)) {
-			case FacesConfigPackage.RENDERER_CLASS_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.RENDERER_CLASS_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RendererExtensionTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RendererExtensionTypeItemProvider.java
deleted file mode 100644
index 16659ad..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RendererExtensionTypeItemProvider.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.edit.provider.IEditingDomainItemProvider;
-import org.eclipse.emf.edit.provider.IItemLabelProvider;
-import org.eclipse.emf.edit.provider.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.jst.jsf.facesconfig.emf.RendererExtensionType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RendererExtensionType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public class RendererExtensionTypeItemProvider
-	extends ExtensionTypeItemProvider
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RendererExtensionTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This returns RendererExtensionType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/RendererExtensionType")); //$NON-NLS-1$
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((RendererExtensionType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_RendererExtensionType_type") : //$NON-NLS-1$
-			getString("_UI_RendererExtensionType_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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-		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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RendererTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RendererTypeItemProvider.java
deleted file mode 100644
index e851182..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RendererTypeItemProvider.java
+++ /dev/null
@@ -1,284 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.RendererType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RendererType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class RendererTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RendererTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_RendererType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_RendererType_id_feature", "_UI_RendererType_type"),
-				 FacesConfigPackage.Literals.RENDERER_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.RENDERER_TYPE__DESCRIPTION);
-			childrenFeatures.add(FacesConfigPackage.Literals.RENDERER_TYPE__DISPLAY_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.RENDERER_TYPE__ICON);
-			childrenFeatures.add(FacesConfigPackage.Literals.RENDERER_TYPE__COMPONENT_FAMILY);
-			childrenFeatures.add(FacesConfigPackage.Literals.RENDERER_TYPE__RENDERER_TYPE);
-			childrenFeatures.add(FacesConfigPackage.Literals.RENDERER_TYPE__RENDERER_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.RENDERER_TYPE__FACET);
-			childrenFeatures.add(FacesConfigPackage.Literals.RENDERER_TYPE__ATTRIBUTE);
-			childrenFeatures.add(FacesConfigPackage.Literals.RENDERER_TYPE__RENDERER_EXTENSION);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 RendererType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/RendererType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((RendererType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_RendererType_type") :
-			getString("_UI_RendererType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(RendererType.class)) {
-			case FacesConfigPackage.RENDERER_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.RENDERER_TYPE__DESCRIPTION:
-			case FacesConfigPackage.RENDERER_TYPE__DISPLAY_NAME:
-			case FacesConfigPackage.RENDERER_TYPE__ICON:
-			case FacesConfigPackage.RENDERER_TYPE__COMPONENT_FAMILY:
-			case FacesConfigPackage.RENDERER_TYPE__RENDERER_TYPE:
-			case FacesConfigPackage.RENDERER_TYPE__RENDERER_CLASS:
-			case FacesConfigPackage.RENDERER_TYPE__FACET:
-			case FacesConfigPackage.RENDERER_TYPE__ATTRIBUTE:
-			case FacesConfigPackage.RENDERER_TYPE__RENDERER_EXTENSION:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.RENDERER_TYPE__DESCRIPTION,
-				 FacesConfigFactory.eINSTANCE.createDescriptionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.RENDERER_TYPE__DISPLAY_NAME,
-				 FacesConfigFactory.eINSTANCE.createDisplayNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.RENDERER_TYPE__ICON,
-				 FacesConfigFactory.eINSTANCE.createIconType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.RENDERER_TYPE__COMPONENT_FAMILY,
-				 FacesConfigFactory.eINSTANCE.createComponentFamilyType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.RENDERER_TYPE__RENDERER_TYPE,
-				 FacesConfigFactory.eINSTANCE.createRendererTypeType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.RENDERER_TYPE__RENDERER_CLASS,
-				 FacesConfigFactory.eINSTANCE.createRendererClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.RENDERER_TYPE__FACET,
-				 FacesConfigFactory.eINSTANCE.createFacetType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.RENDERER_TYPE__ATTRIBUTE,
-				 FacesConfigFactory.eINSTANCE.createAttributeType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.RENDERER_TYPE__RENDERER_EXTENSION,
-				 FacesConfigFactory.eINSTANCE.createRendererExtensionType()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	public String getColumnText(Object object, int columnIndex) {
-		RendererType renderer = (RendererType) object;
-		switch (columnIndex) {
-
-		case 0:
-			return renderer.getDisplayName() == null || renderer.getDisplayName().size()==0 ? "" //$NON-NLS-1$
-					: ((DisplayNameType) renderer.getDisplayName().get(0)).getTextContent();
-		case 1:
-			return renderer.getComponentFamily() == null ? "" //$NON-NLS-1$
-					: renderer.getComponentFamily().getTextContent();
-		case 2:
-			return renderer.getRendererType()==null  ? "" //$NON-NLS-1$
-					: renderer.getRendererType().getTextContent();
-		case 3:
-			return renderer.getRendererClass() == null ? "" : renderer //$NON-NLS-1$
-					.getRendererClass().getTextContent();
-		}
-		return null;
-	}
-
-	public Object getColumnImage(Object object, int columnIndex) {
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RendererTypeTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RendererTypeTypeItemProvider.java
deleted file mode 100644
index ed7fbb0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/RendererTypeTypeItemProvider.java
+++ /dev/null
@@ -1,212 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.RendererType;
-import org.eclipse.jst.jsf.facesconfig.emf.RendererTypeType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.RendererTypeType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider 
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class RendererTypeTypeItemProvider extends ItemProviderAdapter implements
-		IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
- 	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RendererTypeTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc --> 
-	 * @param object
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_RendererTypeType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_RendererTypeType_textContent_feature", "_UI_RendererTypeType_type"),
-				 FacesConfigPackage.Literals.RENDERER_TYPE_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc --> 
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_RendererTypeType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_RendererTypeType_id_feature", "_UI_RendererTypeType_type"),
-				 FacesConfigPackage.Literals.RENDERER_TYPE_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns RendererTypeType.gif.
-	 * <!-- begin-user-doc --> <!--
-	 * end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/RendererTypeType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc
-	 * --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((RendererTypeType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_RendererTypeType_type") :
-			getString("_UI_RendererTypeType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(RendererTypeType.class)) {
-			case FacesConfigPackage.RENDERER_TYPE_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.RENDERER_TYPE_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	public String getColumnText(Object object, int columnIndex) {
-		RendererType renderer = (RendererType) object;
-		switch (columnIndex) {
-
-		case 0:
-			return renderer.getDisplayName().get(0) == null ? "" //$NON-NLS-1$
-					: (String) renderer.getDisplayName().get(0);
-		case 1:
-			return renderer.getRendererClass() == null ? "" : renderer //$NON-NLS-1$
-					.getRendererClass().getTextContent();
-		case 2:
-			return renderer.getComponentFamily().getTextContent() == null ? "" //$NON-NLS-1$
-					: renderer.getComponentFamily().getTextContent();
-		case 3:
-			return renderer.getRendererType().getTextContent() == null ? "" //$NON-NLS-1$
-					: renderer.getRendererType().getTextContent();
-		}
-		return null;
-	}
-
-	public Object getColumnImage(Object object, int columnIndex) {
-		// TODO Auto-generated method stub
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ResourceBundleTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ResourceBundleTypeItemProvider.java
deleted file mode 100644
index 8df4e92..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ResourceBundleTypeItemProvider.java
+++ /dev/null
@@ -1,267 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ResourceBundleTypeItemProvider
-    extends ItemProviderAdapter
-    implements	
-        IEditingDomainItemProvider,	
-        IStructuredItemContentProvider,	
-        ITreeItemContentProvider,	
-        IItemLabelProvider,	
-        IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ResourceBundleTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addBaseNamePropertyDescriptor(object);
-			addVarPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Base Name feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addBaseNamePropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ResourceBundleType_baseName_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ResourceBundleType_baseName_feature", "_UI_ResourceBundleType_type"),
-				 FacesConfigPackage.Literals.RESOURCE_BUNDLE_TYPE__BASE_NAME,
-				 true,
-				 false,
-				 true,
-				 null,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Var feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addVarPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ResourceBundleType_var_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ResourceBundleType_var_feature", "_UI_ResourceBundleType_type"),
-				 FacesConfigPackage.Literals.RESOURCE_BUNDLE_TYPE__VAR,
-				 true,
-				 false,
-				 true,
-				 null,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ResourceBundleType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ResourceBundleType_id_feature", "_UI_ResourceBundleType_type"),
-				 FacesConfigPackage.Literals.RESOURCE_BUNDLE_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * 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
-	 */
-    public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.RESOURCE_BUNDLE_TYPE__DESCRIPTION);
-			childrenFeatures.add(FacesConfigPackage.Literals.RESOURCE_BUNDLE_TYPE__DISPLAY_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.RESOURCE_BUNDLE_TYPE__ICON);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    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 ResourceBundleType.gif.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ResourceBundleType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getText(Object object) {
-		String label = ((ResourceBundleType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ResourceBundleType_type") :
-			getString("_UI_ResourceBundleType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-    public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ResourceBundleType.class)) {
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__DESCRIPTION:
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__DISPLAY_NAME:
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__ICON:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-    protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.RESOURCE_BUNDLE_TYPE__DESCRIPTION,
-				 FacesConfigFactory.eINSTANCE.createDescriptionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.RESOURCE_BUNDLE_TYPE__DISPLAY_NAME,
-				 FacesConfigFactory.eINSTANCE.createDisplayNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.RESOURCE_BUNDLE_TYPE__ICON,
-				 FacesConfigFactory.eINSTANCE.createIconType()));
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ResourceHandlerTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ResourceHandlerTypeItemProvider.java
deleted file mode 100644
index 0324d21..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ResourceHandlerTypeItemProvider.java
+++ /dev/null
@@ -1,216 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ResourceHandlerType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ResourceHandlerType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ResourceHandlerTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource,
-		ITableItemLabelProvider{
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceHandlerTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ResourceHandlerType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ResourceHandlerType_textContent_feature", "_UI_ResourceHandlerType_type"),
-				 FacesConfigPackage.Literals.RESOURCE_HANDLER_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ResourceHandlerType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ResourceHandlerType_id_feature", "_UI_ResourceHandlerType_type"),
-				 FacesConfigPackage.Literals.RESOURCE_HANDLER_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This returns ResourceHandlerType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ResourceHandlerType"));
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((ResourceHandlerType) object).getTextContent();
-		return label == null || label.length() == 0 ? getString("_UI_ResourceHandlerType_type")
-				: label;
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ResourceHandlerType.class)) {
-			case FacesConfigPackage.RESOURCE_HANDLER_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.RESOURCE_HANDLER_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		// TODO Auto-generated method stub
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_ResourceHandlerType_type"); //$NON-NLS-1$
-		}
-		return null;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/SmallIconTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/SmallIconTypeItemProvider.java
deleted file mode 100644
index 3972ae6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/SmallIconTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.SmallIconType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.SmallIconType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class SmallIconTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SmallIconTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_SmallIconType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_SmallIconType_textContent_feature", "_UI_SmallIconType_type"),
-				 FacesConfigPackage.Literals.SMALL_ICON_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_SmallIconType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_SmallIconType_id_feature", "_UI_SmallIconType_type"),
-				 FacesConfigPackage.Literals.SMALL_ICON_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns SmallIconType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/SmallIconType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((SmallIconType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_SmallIconType_type") :
-			getString("_UI_SmallIconType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(SmallIconType.class)) {
-			case FacesConfigPackage.SMALL_ICON_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.SMALL_ICON_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/SourceClassTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/SourceClassTypeItemProvider.java
deleted file mode 100644
index ad36381..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/SourceClassTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.SourceClassType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.SourceClassType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class SourceClassTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SourceClassTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_SourceClassType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_SourceClassType_textContent_feature", "_UI_SourceClassType_type"),
-				 FacesConfigPackage.Literals.SOURCE_CLASS_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_SourceClassType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_SourceClassType_id_feature", "_UI_SourceClassType_type"),
-				 FacesConfigPackage.Literals.SOURCE_CLASS_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This returns SourceClassType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/SourceClassType"));
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((SourceClassType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_SourceClassType_type") :
-			getString("_UI_SourceClassType_type") + " " + label;
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(SourceClassType.class)) {
-			case FacesConfigPackage.SOURCE_CLASS_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.SOURCE_CLASS_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/StateManagerTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/StateManagerTypeItemProvider.java
deleted file mode 100644
index 2e9cd5b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/StateManagerTypeItemProvider.java
+++ /dev/null
@@ -1,209 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.StateManagerType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.StateManagerType} object.
- * <!-- begin-user-doc --> 
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class StateManagerTypeItemProvider extends ItemProviderAdapter implements
-		IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc --> 
-	 * @param adapterFactory
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public StateManagerTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc --> 
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_StateManagerType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_StateManagerType_textContent_feature", "_UI_StateManagerType_type"),
-				 FacesConfigPackage.Literals.STATE_MANAGER_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc --> 
-     * @param object
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_StateManagerType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_StateManagerType_id_feature", "_UI_StateManagerType_type"),
-				 FacesConfigPackage.Literals.STATE_MANAGER_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns StateManagerType.gif.
-	 * <!-- begin-user-doc --> <!--
-	 * end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/StateManagerType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc
-	 * --> <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((StateManagerType) object).getTextContent();
-		return label == null || label.length() == 0 ? getString("_UI_StateManagerType_type")
-				: label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(StateManagerType.class)) {
-			case FacesConfigPackage.STATE_MANAGER_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.STATE_MANAGER_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_StateManagerType_type"); //$NON-NLS-1$
-		}
-
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/SuggestedValueTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/SuggestedValueTypeItemProvider.java
deleted file mode 100644
index 28da5cd..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/SuggestedValueTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.SuggestedValueType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.SuggestedValueType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class SuggestedValueTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SuggestedValueTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_SuggestedValueType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_SuggestedValueType_textContent_feature", "_UI_SuggestedValueType_type"),
-				 FacesConfigPackage.Literals.SUGGESTED_VALUE_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_SuggestedValueType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_SuggestedValueType_id_feature", "_UI_SuggestedValueType_type"),
-				 FacesConfigPackage.Literals.SUGGESTED_VALUE_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns SuggestedValueType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/SuggestedValueType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((SuggestedValueType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_SuggestedValueType_type") :
-			getString("_UI_SuggestedValueType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(SuggestedValueType.class)) {
-			case FacesConfigPackage.SUGGESTED_VALUE_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.SUGGESTED_VALUE_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/SupportedLocaleTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/SupportedLocaleTypeItemProvider.java
deleted file mode 100644
index ed772f8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/SupportedLocaleTypeItemProvider.java
+++ /dev/null
@@ -1,186 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.SupportedLocaleType;
-
-/**
- * This is the item provider adapter for a
- * {@link org.eclipse.jst.jsf.facesconfig.emf.SupportedLocaleType} object. <!--
- * begin-user-doc --> <!-- end-user-doc -->
- * 
- * @generated
- */
-@SuppressWarnings("nls")
-public class SupportedLocaleTypeItemProvider extends ItemProviderAdapter
-		implements IEditingDomainItemProvider, IStructuredItemContentProvider,
-		ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc --> 
-	 * @param adapterFactory
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SupportedLocaleTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc --> 
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_SupportedLocaleType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_SupportedLocaleType_textContent_feature", "_UI_SupportedLocaleType_type"),
-				 FacesConfigPackage.Literals.SUPPORTED_LOCALE_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc --> 
-     * @param object
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_SupportedLocaleType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_SupportedLocaleType_id_feature", "_UI_SupportedLocaleType_type"),
-				 FacesConfigPackage.Literals.SUPPORTED_LOCALE_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns SupportedLocaleType.gif.
-	 * <!-- begin-user-doc --> <!--
-	 * end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/SupportedLocaleType"));
-	}
-
-    /**
-     * This returns the label text for the adapted class.
-     * <!-- begin-user-doc
-	 * --> <!-- end-user-doc -->
-     * @generated NOT
-     */
-	public String getText(Object object) {
-        String label = ((SupportedLocaleType)object).getTextContent();
-        return label == null || label.length() == 0 ?
-            getString("_UI_SupportedLocaleType_type") : //$NON-NLS-1$
-            label;
-    }
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(SupportedLocaleType.class)) {
-			case FacesConfigPackage.SUPPORTED_LOCALE_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.SUPPORTED_LOCALE_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/SystemEventClassTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/SystemEventClassTypeItemProvider.java
deleted file mode 100644
index d25776b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/SystemEventClassTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.SystemEventClassType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventClassType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class SystemEventClassTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SystemEventClassTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_SystemEventClassType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_SystemEventClassType_textContent_feature", "_UI_SystemEventClassType_type"),
-				 FacesConfigPackage.Literals.SYSTEM_EVENT_CLASS_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc --> 
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_SystemEventClassType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_SystemEventClassType_id_feature", "_UI_SystemEventClassType_type"),
-				 FacesConfigPackage.Literals.SYSTEM_EVENT_CLASS_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This returns SystemEventClassType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/SystemEventClassType"));
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((SystemEventClassType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_SystemEventClassType_type") :
-			getString("_UI_SystemEventClassType_type") + " " + label;
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(SystemEventClassType.class)) {
-			case FacesConfigPackage.SYSTEM_EVENT_CLASS_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.SYSTEM_EVENT_CLASS_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/SystemEventListenerClassTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/SystemEventListenerClassTypeItemProvider.java
deleted file mode 100644
index be6cfb7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/SystemEventListenerClassTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerClassType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerClassType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class SystemEventListenerClassTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SystemEventListenerClassTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_SystemEventListenerClassType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_SystemEventListenerClassType_textContent_feature", "_UI_SystemEventListenerClassType_type"),
-				 FacesConfigPackage.Literals.SYSTEM_EVENT_LISTENER_CLASS_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_SystemEventListenerClassType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_SystemEventListenerClassType_id_feature", "_UI_SystemEventListenerClassType_type"),
-				 FacesConfigPackage.Literals.SYSTEM_EVENT_LISTENER_CLASS_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This returns SystemEventListenerClassType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/SystemEventListenerClassType"));
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((SystemEventListenerClassType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_SystemEventListenerClassType_type") :
-			getString("_UI_SystemEventListenerClassType_type") + " " + label;
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(SystemEventListenerClassType.class)) {
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_CLASS_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_CLASS_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/SystemEventListenerTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/SystemEventListenerTypeItemProvider.java
deleted file mode 100644
index 7197cab..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/SystemEventListenerTypeItemProvider.java
+++ /dev/null
@@ -1,219 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class SystemEventListenerTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SystemEventListenerTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_SystemEventListenerType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_SystemEventListenerType_id_feature", "_UI_SystemEventListenerType_type"),
-				 FacesConfigPackage.Literals.SYSTEM_EVENT_LISTENER_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_LISTENER_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.SYSTEM_EVENT_LISTENER_TYPE__SOURCE_CLASS);
-		}
-		return childrenFeatures;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 SystemEventListenerType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/SystemEventListenerType"));
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((SystemEventListenerType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_SystemEventListenerType_type") :
-			getString("_UI_SystemEventListenerType_type") + " " + label;
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(SystemEventListenerType.class)) {
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_LISTENER_CLASS:
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_CLASS:
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SOURCE_CLASS:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_LISTENER_CLASS,
-				 FacesConfigFactory.eINSTANCE.createSystemEventListenerClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_CLASS,
-				 FacesConfigFactory.eINSTANCE.createSystemEventClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.SYSTEM_EVENT_LISTENER_TYPE__SOURCE_CLASS,
-				 FacesConfigFactory.eINSTANCE.createSourceClassType()));
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/TagHandlerDelegateFactoryTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/TagHandlerDelegateFactoryTypeItemProvider.java
deleted file mode 100644
index c13c9e7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/TagHandlerDelegateFactoryTypeItemProvider.java
+++ /dev/null
@@ -1,217 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.TagHandlerDelegateFactoryType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.TagHandlerDelegateFactoryType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class TagHandlerDelegateFactoryTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource,
-		ITableItemLabelProvider{
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public TagHandlerDelegateFactoryTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_TagHandlerDelegateFactoryType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_TagHandlerDelegateFactoryType_textContent_feature", "_UI_TagHandlerDelegateFactoryType_type"),
-				 FacesConfigPackage.Literals.TAG_HANDLER_DELEGATE_FACTORY_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_TagHandlerDelegateFactoryType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_TagHandlerDelegateFactoryType_id_feature", "_UI_TagHandlerDelegateFactoryType_type"),
-				 FacesConfigPackage.Literals.TAG_HANDLER_DELEGATE_FACTORY_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This returns TagHandlerDelegateFactoryType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/TagHandlerDelegateFactoryType"));
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((TagHandlerDelegateFactoryType) object).getTextContent();
-		return label == null || label.length() == 0 ? getString("_UI_TagHandlerDelegateFactoryType_type")
-				: label;
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(TagHandlerDelegateFactoryType.class)) {
-			case FacesConfigPackage.TAG_HANDLER_DELEGATE_FACTORY_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.TAG_HANDLER_DELEGATE_FACTORY_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		// TODO Auto-generated method stub
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_TagHandlerDelegateFactoryType_type"); //$NON-NLS-1$
-		}
-		return null;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ToViewIdTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ToViewIdTypeItemProvider.java
deleted file mode 100644
index dc2c6c7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ToViewIdTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ToViewIdType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ToViewIdType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ToViewIdTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ToViewIdTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ToViewIdType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ToViewIdType_textContent_feature", "_UI_ToViewIdType_type"),
-				 FacesConfigPackage.Literals.TO_VIEW_ID_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ToViewIdType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ToViewIdType_id_feature", "_UI_ToViewIdType_type"),
-				 FacesConfigPackage.Literals.TO_VIEW_ID_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns ToViewIdType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ToViewIdType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((ToViewIdType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ToViewIdType_type") :
-			getString("_UI_ToViewIdType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ToViewIdType.class)) {
-			case FacesConfigPackage.TO_VIEW_ID_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.TO_VIEW_ID_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ValidatorClassTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ValidatorClassTypeItemProvider.java
deleted file mode 100644
index 9a6788e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ValidatorClassTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ValidatorClassType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorClassType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ValidatorClassTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValidatorClassTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ValidatorClassType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ValidatorClassType_textContent_feature", "_UI_ValidatorClassType_type"),
-				 FacesConfigPackage.Literals.VALIDATOR_CLASS_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ValidatorClassType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ValidatorClassType_id_feature", "_UI_ValidatorClassType_type"),
-				 FacesConfigPackage.Literals.VALIDATOR_CLASS_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns ValidatorClassType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ValidatorClassType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((ValidatorClassType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ValidatorClassType_type") :
-			getString("_UI_ValidatorClassType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ValidatorClassType.class)) {
-			case FacesConfigPackage.VALIDATOR_CLASS_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.VALIDATOR_CLASS_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ValidatorExtensionTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ValidatorExtensionTypeItemProvider.java
deleted file mode 100644
index aba55e2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ValidatorExtensionTypeItemProvider.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.edit.provider.IEditingDomainItemProvider;
-import org.eclipse.emf.edit.provider.IItemLabelProvider;
-import org.eclipse.emf.edit.provider.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
-import org.eclipse.jst.jsf.facesconfig.emf.ValidatorExtensionType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorExtensionType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public class ValidatorExtensionTypeItemProvider
-    extends ExtensionTypeItemProvider
-    implements	
-        IEditingDomainItemProvider,	
-        IStructuredItemContentProvider,	
-        ITreeItemContentProvider,	
-        IItemLabelProvider,	
-        IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    @SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ValidatorExtensionTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This returns ValidatorExtensionType.gif.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-    public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ValidatorExtensionType")); //$NON-NLS-1$
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-    public String getText(Object object) {
-		String label = ((ValidatorExtensionType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ValidatorExtensionType_type") : //$NON-NLS-1$
-			getString("_UI_ValidatorExtensionType_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
-	 */
-    public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-		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
-	 */
-    protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ValidatorIdTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ValidatorIdTypeItemProvider.java
deleted file mode 100644
index b71789f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ValidatorIdTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ValidatorIdType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorIdType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ValidatorIdTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValidatorIdTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ValidatorIdType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ValidatorIdType_textContent_feature", "_UI_ValidatorIdType_type"),
-				 FacesConfigPackage.Literals.VALIDATOR_ID_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ValidatorIdType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ValidatorIdType_id_feature", "_UI_ValidatorIdType_type"),
-				 FacesConfigPackage.Literals.VALIDATOR_ID_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns ValidatorIdType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ValidatorIdType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((ValidatorIdType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ValidatorIdType_type") :
-			getString("_UI_ValidatorIdType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ValidatorIdType.class)) {
-			case FacesConfigPackage.VALIDATOR_ID_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.VALIDATOR_ID_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ValidatorTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ValidatorTypeItemProvider.java
deleted file mode 100644
index 59cbdc7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ValidatorTypeItemProvider.java
+++ /dev/null
@@ -1,291 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.ecore.EStructuralFeature;
-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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ValidatorType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType} object.
- * <!-- begin-user-doc --> 
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ValidatorTypeItemProvider extends ItemProviderAdapter implements
-		IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc --> 
-	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValidatorTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc --> 
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ValidatorType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ValidatorType_id_feature", "_UI_ValidatorType_type"),
-				 FacesConfigPackage.Literals.VALIDATOR_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * 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
-	 */
-	public Collection getChildrenFeatures(Object object) {
-		if (childrenFeatures == null) {
-			super.getChildrenFeatures(object);
-			childrenFeatures.add(FacesConfigPackage.Literals.VALIDATOR_TYPE__DESCRIPTION);
-			childrenFeatures.add(FacesConfigPackage.Literals.VALIDATOR_TYPE__DISPLAY_NAME);
-			childrenFeatures.add(FacesConfigPackage.Literals.VALIDATOR_TYPE__ICON);
-			childrenFeatures.add(FacesConfigPackage.Literals.VALIDATOR_TYPE__VALIDATOR_ID);
-			childrenFeatures.add(FacesConfigPackage.Literals.VALIDATOR_TYPE__VALIDATOR_CLASS);
-			childrenFeatures.add(FacesConfigPackage.Literals.VALIDATOR_TYPE__ATTRIBUTE);
-			childrenFeatures.add(FacesConfigPackage.Literals.VALIDATOR_TYPE__PROPERTY);
-			childrenFeatures.add(FacesConfigPackage.Literals.VALIDATOR_TYPE__VALIDATOR_EXTENSION);
-		}
-		return childrenFeatures;
-	}
-
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	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 ValidatorType.gif. <!-- begin-user-doc --> <!-- end-user-doc
-	 * -->
-	 * 
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ValidatorType"));
-	}
-
-	/**
-	 * This returns the label text for the adapted class. <!-- begin-user-doc
-	 * --> <!-- end-user-doc -->
-	 * 
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = null;
-
-		if (((ValidatorType) object).getDisplayName() != null
-				&& ((ValidatorType) object).getDisplayName().size() > 0) {
-			label = ((DisplayNameType) ((ValidatorType) object)
-					.getDisplayName().get(0)).getTextContent();
-		}
-		
-		if ((label == null || label.length() == 0) && ((ValidatorType) object).getValidatorId() != null
-				&& ((ValidatorType) object).getValidatorId().getTextContent() != null) {
-			label = ((ValidatorType) object).getValidatorId().getTextContent();
-		}
-
-		if (label == null || label.length() == 0) {
-			if (((ValidatorType) object).getValidatorClass() != null)
-				label = ((ValidatorType) object).getValidatorClass()
-						.getTextContent();
-		}
-		if (label == null || label.length() == 0) {
-			label = ((ValidatorType) object).getId();
-		}
-		return label == null || label.length() == 0 ? getString("_UI_ValidatorType_type")
-				: label;
-//				: getString("_UI_ValidatorType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ValidatorType.class)) {
-			case FacesConfigPackage.VALIDATOR_TYPE__ID:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
-				return;
-			case FacesConfigPackage.VALIDATOR_TYPE__DESCRIPTION:
-			case FacesConfigPackage.VALIDATOR_TYPE__DISPLAY_NAME:
-			case FacesConfigPackage.VALIDATOR_TYPE__ICON:
-			case FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_ID:
-			case FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_CLASS:
-			case FacesConfigPackage.VALIDATOR_TYPE__ATTRIBUTE:
-			case FacesConfigPackage.VALIDATOR_TYPE__PROPERTY:
-			case FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_EXTENSION:
-				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), true, false));
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.VALIDATOR_TYPE__DESCRIPTION,
-				 FacesConfigFactory.eINSTANCE.createDescriptionType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.VALIDATOR_TYPE__DISPLAY_NAME,
-				 FacesConfigFactory.eINSTANCE.createDisplayNameType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.VALIDATOR_TYPE__ICON,
-				 FacesConfigFactory.eINSTANCE.createIconType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.VALIDATOR_TYPE__VALIDATOR_ID,
-				 FacesConfigFactory.eINSTANCE.createValidatorIdType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.VALIDATOR_TYPE__VALIDATOR_CLASS,
-				 FacesConfigFactory.eINSTANCE.createValidatorClassType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.VALIDATOR_TYPE__ATTRIBUTE,
-				 FacesConfigFactory.eINSTANCE.createAttributeType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.VALIDATOR_TYPE__PROPERTY,
-				 FacesConfigFactory.eINSTANCE.createPropertyType()));
-
-		newChildDescriptors.add
-			(createChildParameter
-				(FacesConfigPackage.Literals.VALIDATOR_TYPE__VALIDATOR_EXTENSION,
-				 FacesConfigFactory.eINSTANCE.createValidatorExtensionType()));
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		// TODO Auto-generated method stub
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_ValidatorType_type"); //$NON-NLS-1$
-		}
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ValueClassTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ValueClassTypeItemProvider.java
deleted file mode 100644
index 39c7d6d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ValueClassTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ValueClassType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ValueClassType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ValueClassTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValueClassTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ValueClassType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ValueClassType_textContent_feature", "_UI_ValueClassType_type"),
-				 FacesConfigPackage.Literals.VALUE_CLASS_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ValueClassType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ValueClassType_id_feature", "_UI_ValueClassType_type"),
-				 FacesConfigPackage.Literals.VALUE_CLASS_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns ValueClassType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ValueClassType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((ValueClassType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ValueClassType_type") :
-			getString("_UI_ValueClassType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ValueClassType.class)) {
-			case FacesConfigPackage.VALUE_CLASS_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.VALUE_CLASS_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ValueTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ValueTypeItemProvider.java
deleted file mode 100644
index 1230800..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ValueTypeItemProvider.java
+++ /dev/null
@@ -1,200 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ValueType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ValueType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ValueTypeItemProvider
-	extends ItemProviderAdapter
-	implements	
-		IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValueTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ValueType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ValueType_textContent_feature", "_UI_ValueType_type"),
-				 FacesConfigPackage.Literals.VALUE_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ValueType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ValueType_id_feature", "_UI_ValueType_type"),
-				 FacesConfigPackage.Literals.VALUE_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns ValueType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ValueType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getText(Object object) {
-		String label = ((ValueType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_ValueType_type") :
-			getString("_UI_ValueType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ValueType.class)) {
-			case FacesConfigPackage.VALUE_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.VALUE_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	public String getColumnText(Object object, int columnIndex) {
-
-		ValueType value = (ValueType)object;
-		return value.getTextContent();
-	}
-
-	public Object getColumnImage(Object object, int columnIndex) {
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/VarTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/VarTypeItemProvider.java
deleted file mode 100644
index 91b1d96..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/VarTypeItemProvider.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.VarType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.VarType} object.
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class VarTypeItemProvider
-    extends ItemProviderAdapter
-    implements	
-        IEditingDomainItemProvider,	
-        IStructuredItemContentProvider,	
-        ITreeItemContentProvider,	
-        IItemLabelProvider,	
-        IItemPropertySource {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-     * @param adapterFactory 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public VarTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-    /**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-    /**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_VarType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_VarType_textContent_feature", "_UI_VarType_type"),
-				 FacesConfigPackage.Literals.VAR_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_VarType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_VarType_id_feature", "_UI_VarType_type"),
-				 FacesConfigPackage.Literals.VAR_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns VarType.gif.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/VarType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getText(Object object) {
-		String label = ((VarType)object).getId();
-		return label == null || label.length() == 0 ?
-			getString("_UI_VarType_type") :
-			getString("_UI_VarType_type") + " " + label;
-	}
-
-    /**
-	 * 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
-	 */
-    public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(VarType.class)) {
-			case FacesConfigPackage.VAR_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.VAR_TYPE__ID:
-				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
-	 */
-    protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-    /**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/VariableResolverTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/VariableResolverTypeItemProvider.java
deleted file mode 100644
index 38b6260..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/VariableResolverTypeItemProvider.java
+++ /dev/null
@@ -1,209 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.VariableResolverType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.VariableResolverType} object.
- * <!-- begin-user-doc --> 
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class VariableResolverTypeItemProvider extends ItemProviderAdapter
-		implements IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc --> 
- 	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public VariableResolverTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc --> 
-	 * @param object
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_VariableResolverType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_VariableResolverType_textContent_feature", "_UI_VariableResolverType_type"),
-				 FacesConfigPackage.Literals.VARIABLE_RESOLVER_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc --> 
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_VariableResolverType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_VariableResolverType_id_feature", "_UI_VariableResolverType_type"),
-				 FacesConfigPackage.Literals.VARIABLE_RESOLVER_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns VariableResolverType.gif.
-	 * <!-- begin-user-doc --> <!--
-	 * end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/VariableResolverType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc
-	 * --> <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((VariableResolverType) object).getTextContent();
-		return label == null || label.length() == 0 ? getString("_UI_VariableResolverType_type")
-				: label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(VariableResolverType.class)) {
-			case FacesConfigPackage.VARIABLE_RESOLVER_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.VARIABLE_RESOLVER_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_VariableResolverType_type"); //$NON-NLS-1$
-		}
-
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ViewDeclarationLanguageFactoryTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ViewDeclarationLanguageFactoryTypeItemProvider.java
deleted file mode 100644
index 7e2b6d8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ViewDeclarationLanguageFactoryTypeItemProvider.java
+++ /dev/null
@@ -1,217 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ViewDeclarationLanguageFactoryType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ViewDeclarationLanguageFactoryType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ViewDeclarationLanguageFactoryTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource,
-		ITableItemLabelProvider{
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ViewDeclarationLanguageFactoryTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ViewDeclarationLanguageFactoryType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ViewDeclarationLanguageFactoryType_textContent_feature", "_UI_ViewDeclarationLanguageFactoryType_type"),
-				 FacesConfigPackage.Literals.VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc -->
-	 * @param object
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ViewDeclarationLanguageFactoryType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ViewDeclarationLanguageFactoryType_id_feature", "_UI_ViewDeclarationLanguageFactoryType_type"),
-				 FacesConfigPackage.Literals.VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This returns ViewDeclarationLanguageFactoryType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ViewDeclarationLanguageFactoryType"));
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((ViewDeclarationLanguageFactoryType) object).getTextContent();
-		return label == null || label.length() == 0 ? getString("_UI_ViewDeclarationLanguageFactoryType_type")
-				: label;
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ViewDeclarationLanguageFactoryType.class)) {
-			case FacesConfigPackage.VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		// TODO Auto-generated method stub
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_ViewDeclarationLanguageFactoryType_type"); //$NON-NLS-1$
-		}
-		return null;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ViewHandlerTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ViewHandlerTypeItemProvider.java
deleted file mode 100644
index 8cd0a0d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/ViewHandlerTypeItemProvider.java
+++ /dev/null
@@ -1,209 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ViewHandlerType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.ViewHandlerType} object.
- * <!-- begin-user-doc --> 
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class ViewHandlerTypeItemProvider extends ItemProviderAdapter implements
-		IEditingDomainItemProvider, IStructuredItemContentProvider, ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource, ITableItemLabelProvider {
-    /**
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc --> 
-	 * @param adapterFactory
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ViewHandlerTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc --> 
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ViewHandlerType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ViewHandlerType_textContent_feature", "_UI_ViewHandlerType_type"),
-				 FacesConfigPackage.Literals.VIEW_HANDLER_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc --> 
-     * @param object 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_ViewHandlerType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_ViewHandlerType_id_feature", "_UI_ViewHandlerType_type"),
-				 FacesConfigPackage.Literals.VIEW_HANDLER_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-    /**
-	 * This returns ViewHandlerType.gif.
-	 * <!-- begin-user-doc --> <!--
-	 * end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/ViewHandlerType"));
-	}
-
-    /**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc
-	 * --> <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((ViewHandlerType) object).getTextContent();
-		return label == null || label.length() == 0 ? getString("_UI_ViewHandlerType_type")
-				: label;
-	}
-
-    /**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(ViewHandlerType.class)) {
-			case FacesConfigPackage.VIEW_HANDLER_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.VIEW_HANDLER_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources. <!--
-	 * begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_ViewHandlerType_type"); //$NON-NLS-1$
-		}
-
-		return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/VisitContextFactoryTypeItemProvider.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/VisitContextFactoryTypeItemProvider.java
deleted file mode 100644
index a2acdb4..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/VisitContextFactoryTypeItemProvider.java
+++ /dev/null
@@ -1,217 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.edit.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.IItemPropertySource;
-import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
-import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
-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.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.VisitContextFactoryType;
-
-/**
- * This is the item provider adapter for a {@link org.eclipse.jst.jsf.facesconfig.emf.VisitContextFactoryType} object.
- * <!-- begin-user-doc -->
- * @extends ITableItemLabelProvider
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class VisitContextFactoryTypeItemProvider
-	extends ItemProviderAdapter
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource,
-		ITableItemLabelProvider{
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * This constructs an instance from a factory and a notifier.
-	 * <!-- begin-user-doc -->
-	 * @param adapterFactory 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public VisitContextFactoryTypeItemProvider(AdapterFactory adapterFactory) {
-		super(adapterFactory);
-	}
-
-	/**
-	 * This returns the property descriptors for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public List getPropertyDescriptors(Object object) {
-		if (itemPropertyDescriptors == null) {
-			super.getPropertyDescriptors(object);
-
-			addTextContentPropertyDescriptor(object);
-			addIdPropertyDescriptor(object);
-		}
-		return itemPropertyDescriptors;
-	}
-
-	/**
-	 * This adds a property descriptor for the Text Content feature.
-	 * <!-- begin-user-doc --> 
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addTextContentPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_VisitContextFactoryType_textContent_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_VisitContextFactoryType_textContent_feature", "_UI_VisitContextFactoryType_type"),
-				 FacesConfigPackage.Literals.VISIT_CONTEXT_FACTORY_TYPE__TEXT_CONTENT,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This adds a property descriptor for the Id feature.
-	 * <!-- begin-user-doc --> 
-	 * @param object 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void addIdPropertyDescriptor(Object object) {
-		itemPropertyDescriptors.add
-			(createItemPropertyDescriptor
-				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
-				 getResourceLocator(),
-				 getString("_UI_VisitContextFactoryType_id_feature"),
-				 getString("_UI_PropertyDescriptor_description", "_UI_VisitContextFactoryType_id_feature", "_UI_VisitContextFactoryType_type"),
-				 FacesConfigPackage.Literals.VISIT_CONTEXT_FACTORY_TYPE__ID,
-				 true,
-				 false,
-				 false,
-				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
-				 null,
-				 null));
-	}
-
-	/**
-	 * This returns VisitContextFactoryType.gif.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object getImage(Object object) {
-		return overlayImage(object, getResourceLocator().getImage("full/obj16/VisitContextFactoryType"));
-	}
-
-	/**
-	 * This returns the label text for the adapted class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String getText(Object object) {
-		String label = ((VisitContextFactoryType) object).getTextContent();
-		return label == null || label.length() == 0 ? getString("_UI_VisitContextFactoryType_type")
-				: label;
-	}
-
-	/**
-	 * 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
-	 */
-	public void notifyChanged(Notification notification) {
-		updateChildren(notification);
-
-		switch (notification.getFeatureID(VisitContextFactoryType.class)) {
-			case FacesConfigPackage.VISIT_CONTEXT_FACTORY_TYPE__TEXT_CONTENT:
-			case FacesConfigPackage.VISIT_CONTEXT_FACTORY_TYPE__ID:
-				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
-	 */
-	protected void collectNewChildDescriptors(Collection newChildDescriptors, Object object) {
-		super.collectNewChildDescriptors(newChildDescriptors, object);
-	}
-
-	/**
-	 * Return the resource locator for this item provider's resources.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceLocator getResourceLocator() {
-		return FacesConfigPlugin.INSTANCE;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnImage(java.lang.Object, int)
-	 */
-	public Object getColumnImage(Object object, int columnIndex) {
-		// TODO Auto-generated method stub
-		if(columnIndex ==0)
-			return getImage(object);
-		return null;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.emf.edit.provider.ITableItemLabelProvider#getColumnText(java.lang.Object, int)
-	 */
-	public String getColumnText(Object object, int columnIndex) {
-		switch (columnIndex) {
-
-		case 0:
-			return getText(object);
-		case 1:
-			return getString("_UI_VisitContextFactoryType_type"); //$NON-NLS-1$
-		}
-		return null;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/package-info.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/package-info.java
deleted file mode 100644
index 71a1afa..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/edit/provider/package-info.java
+++ /dev/null
@@ -1,16 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Oracle - initial API and implementation
- *    
- ********************************************************************************/
-
-/**
- * EMF providers for JSF application configuration model. 
- */
-package org.eclipse.jst.jsf.facesconfig.edit.provider;
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/AbsoluteOrderingType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/AbsoluteOrderingType.java
deleted file mode 100644
index c874529..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/AbsoluteOrderingType.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Absolute Ordering Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.AbsoluteOrderingType#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.AbsoluteOrderingType#getOthers <em>Others</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getAbsoluteOrderingType()
- * @model extendedMetaData="name='absolute-ordering_._type' kind='elementOnly'"
- * @generated
- */
-public interface AbsoluteOrderingType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Name</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.NameType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Name</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>Name</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getAbsoluteOrderingType_Name()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.NameType" containment="true"
-	 *        extendedMetaData="kind='element' name='name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getName();
-
-	/**
-	 * Returns the value of the '<em><b>Others</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Others</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Others</em>' containment reference.
-	 * @see #setOthers(OrderingOthersType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getAbsoluteOrderingType_Others()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='others' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	OrderingOthersType getOthers();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.AbsoluteOrderingType#getOthers <em>Others</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Others</em>' containment reference.
-	 * @see #getOthers()
-	 * @generated
-	 */
-	void setOthers(OrderingOthersType value);
-
-} // AbsoluteOrderingType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ActionListenerType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ActionListenerType.java
deleted file mode 100644
index 272bb43..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ActionListenerType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Action Listener Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ActionListenerType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ActionListenerType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getActionListenerType()
- * @model extendedMetaData="name='action-listener_._type' kind='simple'"
- * @generated
- */
-public interface ActionListenerType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getActionListenerType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ActionListenerType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getActionListenerType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ActionListenerType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ActionListenerType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ApplicationExtensionType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ApplicationExtensionType.java
deleted file mode 100644
index 09e2e93..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ApplicationExtensionType.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Application Extension Type</b></em>'.
- * <!-- end-user-doc -->
- *
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getApplicationExtensionType()
- * @model extendedMetaData="name='application-extension_._type'"
- * @generated
- */
-public interface ApplicationExtensionType extends ExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-} // ApplicationExtensionType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ApplicationFactoryType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ApplicationFactoryType.java
deleted file mode 100644
index 72c50ca..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ApplicationFactoryType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Application Factory Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationFactoryType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationFactoryType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getApplicationFactoryType()
- * @model extendedMetaData="name='application-factory_._type' kind='simple'"
- * @generated
- */
-public interface ApplicationFactoryType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getApplicationFactoryType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationFactoryType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getApplicationFactoryType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationFactoryType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ApplicationFactoryType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ApplicationType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ApplicationType.java
deleted file mode 100644
index ea98ef6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ApplicationType.java
+++ /dev/null
@@ -1,338 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Application Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getActionListener <em>Action Listener</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getDefaultRenderKitId <em>Default Render Kit Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getMessageBundle <em>Message Bundle</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getNavigationHandler <em>Navigation Handler</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getViewHandler <em>View Handler</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getStateManager <em>State Manager</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getELResolver <em>EL Resolver</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getPropertyResolver <em>Property Resolver</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getVariableResolver <em>Variable Resolver</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getResourceHandler <em>Resource Handler</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getSystemEventListener <em>System Event Listener</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getLocaleConfig <em>Locale Config</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getResourceBundle <em>Resource Bundle</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getApplicationExtension <em>Application Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getDefaultValidators <em>Default Validators</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getApplicationType()
- * @model extendedMetaData="name='application_._type' kind='elementOnly'"
- * @generated
- */
-public interface ApplicationType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Action Listener</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ActionListenerType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Action Listener</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>Action Listener</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getApplicationType_ActionListener()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ActionListenerType" containment="true"
-	 *        extendedMetaData="kind='element' name='action-listener' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getActionListener();
-
-    /**
-	 * Returns the value of the '<em><b>Default Render Kit Id</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DefaultRenderKitIdType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Default Render Kit Id</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>Default Render Kit Id</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getApplicationType_DefaultRenderKitId()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DefaultRenderKitIdType" containment="true"
-	 *        extendedMetaData="kind='element' name='default-render-kit-id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDefaultRenderKitId();
-
-    /**
-	 * Returns the value of the '<em><b>Message Bundle</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.MessageBundleType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Message Bundle</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>Message Bundle</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getApplicationType_MessageBundle()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.MessageBundleType" containment="true"
-	 *        extendedMetaData="kind='element' name='message-bundle' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getMessageBundle();
-
-    /**
-	 * Returns the value of the '<em><b>Navigation Handler</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.NavigationHandlerType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Navigation Handler</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>Navigation Handler</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getApplicationType_NavigationHandler()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.NavigationHandlerType" containment="true"
-	 *        extendedMetaData="kind='element' name='navigation-handler' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getNavigationHandler();
-
-    /**
-	 * Returns the value of the '<em><b>View Handler</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ViewHandlerType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>View Handler</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>View Handler</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getApplicationType_ViewHandler()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ViewHandlerType" containment="true"
-	 *        extendedMetaData="kind='element' name='view-handler' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getViewHandler();
-
-    /**
-	 * Returns the value of the '<em><b>State Manager</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.StateManagerType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>State Manager</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>State Manager</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getApplicationType_StateManager()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.StateManagerType" containment="true"
-	 *        extendedMetaData="kind='element' name='state-manager' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getStateManager();
-
-    /**
-	 * Returns the value of the '<em><b>Property Resolver</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.PropertyResolverType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Property Resolver</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>Property Resolver</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getApplicationType_PropertyResolver()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.PropertyResolverType" containment="true"
-	 *        extendedMetaData="kind='element' name='property-resolver' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getPropertyResolver();
-
-    /**
-	 * Returns the value of the '<em><b>Variable Resolver</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.VariableResolverType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Variable Resolver</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>Variable Resolver</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getApplicationType_VariableResolver()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.VariableResolverType" containment="true"
-	 *        extendedMetaData="kind='element' name='variable-resolver' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getVariableResolver();
-
-    /**
-	 * Returns the value of the '<em><b>Resource Handler</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ResourceHandlerType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Resource Handler</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>Resource Handler</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getApplicationType_ResourceHandler()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ResourceHandlerType" containment="true"
-	 *        extendedMetaData="kind='element' name='resource-handler' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getResourceHandler();
-
-				/**
-	 * Returns the value of the '<em><b>System Event Listener</b></em>' reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>System Event Listener</em>' reference list isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>System Event Listener</em>' reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getApplicationType_SystemEventListener()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType"
-	 *        extendedMetaData="kind='element' name='system-event-listener' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getSystemEventListener();
-
-				/**
-	 * Returns the value of the '<em><b>Locale Config</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Locale Config</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>Locale Config</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getApplicationType_LocaleConfig()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType" containment="true"
-	 *        extendedMetaData="kind='element' name='locale-config' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getLocaleConfig();
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getApplicationType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-    /**
-	 * Returns the value of the '<em><b>EL Resolver</b></em>' reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ELResolverType}.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>EL Resolver</em>' reference list isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-	 * @return the value of the '<em>EL Resolver</em>' reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getApplicationType_ELResolver()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ELResolverType"
-	 *        extendedMetaData="kind='element' name='el-resolver' namespace='##targetNamespace'"
-	 * @generated
-	 */
-    EList getELResolver();
-
-    /**
-	 * Returns the value of the '<em><b>Resource Bundle</b></em>' reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType}.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Resource Bundle</em>' reference list isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-	 * @return the value of the '<em>Resource Bundle</em>' reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getApplicationType_ResourceBundle()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType"
-	 *        extendedMetaData="kind='element' name='resource-bundle' namespace='##targetNamespace'"
-	 * @generated
-	 */
-    EList getResourceBundle();
-
-    /**
-	 * Returns the value of the '<em><b>Application Extension</b></em>' reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationExtensionType}.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Application Extension</em>' reference list isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-	 * @return the value of the '<em>Application Extension</em>' reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getApplicationType_ApplicationExtension()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ApplicationExtensionType"
-	 *        extendedMetaData="kind='element' name='application-extension' namespace='##targetNamespace'"
-	 * @generated
-	 */
-    EList getApplicationExtension();
-
-				/**
-	 * Returns the value of the '<em><b>Default Validators</b></em>' reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValidatorsType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Default Validators</em>' reference list isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Default Validators</em>' reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getApplicationType_DefaultValidators()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DefaultValidatorsType"
-	 *        extendedMetaData="kind='element' name='default-validators' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDefaultValidators();
-
-} // ApplicationType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/AttributeClassType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/AttributeClassType.java
deleted file mode 100644
index a19aa9e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/AttributeClassType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Attribute Class Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeClassType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeClassType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getAttributeClassType()
- * @model extendedMetaData="name='attribute-class_._type' kind='simple'"
- * @generated
- */
-public interface AttributeClassType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getAttributeClassType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeClassType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getAttributeClassType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeClassType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // AttributeClassType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/AttributeExtensionType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/AttributeExtensionType.java
deleted file mode 100644
index 422dcc5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/AttributeExtensionType.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Attribute Extension Type</b></em>'.
- * <!-- end-user-doc -->
- *
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getAttributeExtensionType()
- * @model extendedMetaData="name='attribute-extension_._type'"
- * @generated
- */
-public interface AttributeExtensionType extends ExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-} // AttributeExtensionType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/AttributeNameType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/AttributeNameType.java
deleted file mode 100644
index c44d47f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/AttributeNameType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Attribute Name Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeNameType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeNameType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getAttributeNameType()
- * @model extendedMetaData="name='attribute-name_._type' kind='simple'"
- * @generated
- */
-public interface AttributeNameType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getAttributeNameType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeNameType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getAttributeNameType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeNameType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // AttributeNameType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/AttributeType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/AttributeType.java
deleted file mode 100644
index 0fb14f6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/AttributeType.java
+++ /dev/null
@@ -1,252 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Attribute Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getAttributeName <em>Attribute Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getAttributeClass <em>Attribute Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getDefaultValue <em>Default Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getSuggestedValue <em>Suggested Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getAttributeExtension <em>Attribute Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getAttributeType()
- * @model extendedMetaData="name='attribute_._type' kind='elementOnly'"
- * @generated
- */
-public interface AttributeType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Description</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Description</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>Description</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getAttributeType_Description()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DescriptionType" containment="true"
-	 *        extendedMetaData="kind='element' name='description' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDescription();
-
-    /**
-	 * Returns the value of the '<em><b>Display Name</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Display Name</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>Display Name</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getAttributeType_DisplayName()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType" containment="true"
-	 *        extendedMetaData="kind='element' name='display-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDisplayName();
-
-    /**
-	 * Returns the value of the '<em><b>Icon</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.IconType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Icon</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>Icon</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getAttributeType_Icon()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.IconType" containment="true"
-	 *        extendedMetaData="kind='element' name='icon' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getIcon();
-
-    /**
-	 * Returns the value of the '<em><b>Attribute Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Attribute Name</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Attribute Name</em>' containment reference.
-	 * @see #setAttributeName(AttributeNameType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getAttributeType_AttributeName()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='attribute-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	AttributeNameType getAttributeName();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getAttributeName <em>Attribute Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Attribute Name</em>' containment reference.
-	 * @see #getAttributeName()
-	 * @generated
-	 */
-	void setAttributeName(AttributeNameType value);
-
-    /**
-	 * Returns the value of the '<em><b>Attribute Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Attribute Class</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Attribute Class</em>' containment reference.
-	 * @see #setAttributeClass(AttributeClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getAttributeType_AttributeClass()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='attribute-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	AttributeClassType getAttributeClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getAttributeClass <em>Attribute Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Attribute Class</em>' containment reference.
-	 * @see #getAttributeClass()
-	 * @generated
-	 */
-	void setAttributeClass(AttributeClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Default Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Default Value</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Default Value</em>' containment reference.
-	 * @see #setDefaultValue(DefaultValueType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getAttributeType_DefaultValue()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='default-value' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	DefaultValueType getDefaultValue();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getDefaultValue <em>Default Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Default Value</em>' containment reference.
-	 * @see #getDefaultValue()
-	 * @generated
-	 */
-	void setDefaultValue(DefaultValueType value);
-
-    /**
-	 * Returns the value of the '<em><b>Suggested Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Suggested Value</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Suggested Value</em>' containment reference.
-	 * @see #setSuggestedValue(SuggestedValueType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getAttributeType_SuggestedValue()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='suggested-value' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	SuggestedValueType getSuggestedValue();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getSuggestedValue <em>Suggested Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Suggested Value</em>' containment reference.
-	 * @see #getSuggestedValue()
-	 * @generated
-	 */
-	void setSuggestedValue(SuggestedValueType value);
-
-    /**
-	 * Returns the value of the '<em><b>Attribute Extension</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.AttributeExtensionType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Attribute Extension</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>Attribute Extension</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getAttributeType_AttributeExtension()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.AttributeExtensionType" containment="true"
-	 *        extendedMetaData="kind='element' name='attribute-extension' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getAttributeExtension();
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getAttributeType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // AttributeType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/BaseNameType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/BaseNameType.java
deleted file mode 100644
index 7fe6f63..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/BaseNameType.java
+++ /dev/null
@@ -1,94 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Base Name Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.BaseNameType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.BaseNameType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getBaseNameType()
- * @model extendedMetaData="name='base-name_._type' kind='simple'"
- * @generated
- */
-public interface BaseNameType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getBaseNameType_TextContent()
-	 * @model extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-    String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.BaseNameType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-    void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Id</em>' attribute isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getBaseNameType_Id()
-	 * @model id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-    String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.BaseNameType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-    void setId(String value);
-
-} // BaseNameType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/BehaviorClassType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/BehaviorClassType.java
deleted file mode 100644
index 78ffb25..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/BehaviorClassType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Behavior Class Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorClassType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorClassType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getBehaviorClassType()
- * @model extendedMetaData="name='behavior-class_._type' kind='simple'"
- * @generated
- */
-public interface BehaviorClassType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getBehaviorClassType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorClassType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getBehaviorClassType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorClassType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // BehaviorClassType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/BehaviorExtensionType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/BehaviorExtensionType.java
deleted file mode 100644
index 699e5ce..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/BehaviorExtensionType.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Behavior Extension Type</b></em>'.
- * <!-- end-user-doc -->
- *
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getBehaviorExtensionType()
- * @model extendedMetaData="name='behavior-extension_._type'"
- * @generated
- */
-public interface BehaviorExtensionType extends ExtensionType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-} // BehaviorExtensionType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/BehaviorIdType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/BehaviorIdType.java
deleted file mode 100644
index cacea62..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/BehaviorIdType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Behavior Id Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorIdType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorIdType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getBehaviorIdType()
- * @model extendedMetaData="name='behavior-id_._type' kind='simple'"
- * @generated
- */
-public interface BehaviorIdType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getBehaviorIdType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorIdType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getBehaviorIdType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorIdType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // BehaviorIdType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/BehaviorType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/BehaviorType.java
deleted file mode 100644
index a9eb3df..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/BehaviorType.java
+++ /dev/null
@@ -1,204 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Behavior Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getBehaviorId <em>Behavior Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getBehaviorClass <em>Behavior Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getAttribute <em>Attribute</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getProperty <em>Property</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getBehaviorExtension <em>Behavior Extension</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getBehaviorType()
- * @model extendedMetaData="name='behavior_._type' kind='elementOnly'"
- * @generated
- */
-public interface BehaviorType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Description</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Description</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>Description</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getBehaviorType_Description()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DescriptionType" containment="true"
-	 *        extendedMetaData="kind='element' name='description' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDescription();
-
-	/**
-	 * Returns the value of the '<em><b>Display Name</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Display Name</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>Display Name</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getBehaviorType_DisplayName()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType" containment="true"
-	 *        extendedMetaData="kind='element' name='display-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDisplayName();
-
-	/**
-	 * Returns the value of the '<em><b>Icon</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.IconType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Icon</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>Icon</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getBehaviorType_Icon()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.IconType" containment="true"
-	 *        extendedMetaData="kind='element' name='icon' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getIcon();
-
-	/**
-	 * Returns the value of the '<em><b>Behavior Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Behavior Id</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Behavior Id</em>' containment reference.
-	 * @see #setBehaviorId(BehaviorIdType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getBehaviorType_BehaviorId()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='behavior-id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	BehaviorIdType getBehaviorId();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getBehaviorId <em>Behavior Id</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Behavior Id</em>' containment reference.
-	 * @see #getBehaviorId()
-	 * @generated
-	 */
-	void setBehaviorId(BehaviorIdType value);
-
-	/**
-	 * Returns the value of the '<em><b>Behavior Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Behavior Class</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Behavior Class</em>' containment reference.
-	 * @see #setBehaviorClass(BehaviorClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getBehaviorType_BehaviorClass()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='behavior-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	BehaviorClassType getBehaviorClass();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getBehaviorClass <em>Behavior Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Behavior Class</em>' containment reference.
-	 * @see #getBehaviorClass()
-	 * @generated
-	 */
-	void setBehaviorClass(BehaviorClassType value);
-
-	/**
-	 * Returns the value of the '<em><b>Attribute</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Attribute</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>Attribute</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getBehaviorType_Attribute()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.AttributeType" containment="true"
-	 *        extendedMetaData="kind='element' name='attribute' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getAttribute();
-
-	/**
-	 * Returns the value of the '<em><b>Property</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Property</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>Property</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getBehaviorType_Property()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.PropertyType" containment="true"
-	 *        extendedMetaData="kind='element' name='property' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getProperty();
-
-	/**
-	 * Returns the value of the '<em><b>Behavior Extension</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorExtensionType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Behavior Extension</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>Behavior Extension</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getBehaviorType_BehaviorExtension()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.BehaviorExtensionType" containment="true"
-	 *        extendedMetaData="kind='element' name='behavior-extension' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getBehaviorExtension();
-
-} // BehaviorType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ClientBehaviorRendererClassType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ClientBehaviorRendererClassType.java
deleted file mode 100644
index b99d00f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ClientBehaviorRendererClassType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Client Behavior Renderer Class Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererClassType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererClassType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getClientBehaviorRendererClassType()
- * @model extendedMetaData="name='client-behavior-renderer-class_._type' kind='simple'"
- * @generated
- */
-public interface ClientBehaviorRendererClassType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getClientBehaviorRendererClassType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererClassType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getClientBehaviorRendererClassType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererClassType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ClientBehaviorRendererClassType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ClientBehaviorRendererType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ClientBehaviorRendererType.java
deleted file mode 100644
index 9428d03..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ClientBehaviorRendererType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Client Behavior Renderer Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererType#getClientBehaviorRendererType <em>Client Behavior Renderer Type</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererType#getClientBehaviorRendererClass <em>Client Behavior Renderer Class</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getClientBehaviorRendererType()
- * @model extendedMetaData="name='client-behavior-renderer_._type' kind='elementOnly'"
- * @generated
- */
-public interface ClientBehaviorRendererType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Client Behavior Renderer Type</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Client Behavior Renderer Type</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Client Behavior Renderer Type</em>' containment reference.
-	 * @see #setClientBehaviorRendererType(ClientBehaviorRendererTypeType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getClientBehaviorRendererType_ClientBehaviorRendererType()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='client-behavior-renderer-type' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ClientBehaviorRendererTypeType getClientBehaviorRendererType();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererType#getClientBehaviorRendererType <em>Client Behavior Renderer Type</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Client Behavior Renderer Type</em>' containment reference.
-	 * @see #getClientBehaviorRendererType()
-	 * @generated
-	 */
-	void setClientBehaviorRendererType(ClientBehaviorRendererTypeType value);
-
-	/**
-	 * Returns the value of the '<em><b>Client Behavior Renderer Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Client Behavior Renderer Class</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Client Behavior Renderer Class</em>' containment reference.
-	 * @see #setClientBehaviorRendererClass(ClientBehaviorRendererClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getClientBehaviorRendererType_ClientBehaviorRendererClass()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='client-behavior-renderer-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ClientBehaviorRendererClassType getClientBehaviorRendererClass();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererType#getClientBehaviorRendererClass <em>Client Behavior Renderer Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Client Behavior Renderer Class</em>' containment reference.
-	 * @see #getClientBehaviorRendererClass()
-	 * @generated
-	 */
-	void setClientBehaviorRendererClass(ClientBehaviorRendererClassType value);
-
-} // ClientBehaviorRendererType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ClientBehaviorRendererTypeType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ClientBehaviorRendererTypeType.java
deleted file mode 100644
index 5b6c47a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ClientBehaviorRendererTypeType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Client Behavior Renderer Type Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererTypeType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererTypeType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getClientBehaviorRendererTypeType()
- * @model extendedMetaData="name='client-behavior-renderer-type_._type' kind='simple'"
- * @generated
- */
-public interface ClientBehaviorRendererTypeType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getClientBehaviorRendererTypeType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererTypeType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getClientBehaviorRendererTypeType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererTypeType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ClientBehaviorRendererTypeType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ComponentClassType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ComponentClassType.java
deleted file mode 100644
index d970637..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ComponentClassType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Component Class Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentClassType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentClassType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getComponentClassType()
- * @model extendedMetaData="name='component-class_._type' kind='simple'"
- * @generated
- */
-public interface ComponentClassType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getComponentClassType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentClassType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getComponentClassType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentClassType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ComponentClassType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ComponentExtensionType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ComponentExtensionType.java
deleted file mode 100644
index efd1b71..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ComponentExtensionType.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Component Extension Type</b></em>'.
- * <!-- end-user-doc -->
- *
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getComponentExtensionType()
- * @model extendedMetaData="name='component-extension_._type'"
- * @generated
- */
-public interface ComponentExtensionType extends ExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-} // ComponentExtensionType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ComponentFamilyType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ComponentFamilyType.java
deleted file mode 100644
index 4079ca0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ComponentFamilyType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Component Family Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentFamilyType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentFamilyType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getComponentFamilyType()
- * @model extendedMetaData="name='component-family_._type' kind='simple'"
- * @generated
- */
-public interface ComponentFamilyType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getComponentFamilyType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentFamilyType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getComponentFamilyType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentFamilyType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ComponentFamilyType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ComponentType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ComponentType.java
deleted file mode 100644
index bbd4673..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ComponentType.java
+++ /dev/null
@@ -1,250 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Component Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getComponentType <em>Component Type</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getComponentClass <em>Component Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getFacet <em>Facet</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getAttribute <em>Attribute</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getProperty <em>Property</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getComponentExtension <em>Component Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getComponentType()
- * @model extendedMetaData="name='component_._type' kind='elementOnly'"
- * @generated
- */
-public interface ComponentType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Description</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Description</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>Description</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getComponentType_Description()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DescriptionType" containment="true"
-	 *        extendedMetaData="kind='element' name='description' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDescription();
-
-    /**
-	 * Returns the value of the '<em><b>Display Name</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Display Name</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>Display Name</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getComponentType_DisplayName()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType" containment="true"
-	 *        extendedMetaData="kind='element' name='display-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDisplayName();
-
-    /**
-	 * Returns the value of the '<em><b>Icon</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.IconType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Icon</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>Icon</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getComponentType_Icon()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.IconType" containment="true"
-	 *        extendedMetaData="kind='element' name='icon' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getIcon();
-
-    /**
-	 * Returns the value of the '<em><b>Component Type</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Component Type</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Component Type</em>' containment reference.
-	 * @see #setComponentType(ComponentTypeType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getComponentType_ComponentType()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='component-type' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ComponentTypeType getComponentType();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getComponentType <em>Component Type</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Component Type</em>' containment reference.
-	 * @see #getComponentType()
-	 * @generated
-	 */
-	void setComponentType(ComponentTypeType value);
-
-    /**
-	 * Returns the value of the '<em><b>Component Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Component Class</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Component Class</em>' containment reference.
-	 * @see #setComponentClass(ComponentClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getComponentType_ComponentClass()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='component-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ComponentClassType getComponentClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getComponentClass <em>Component Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Component Class</em>' containment reference.
-	 * @see #getComponentClass()
-	 * @generated
-	 */
-	void setComponentClass(ComponentClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Facet</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.FacetType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Facet</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>Facet</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getComponentType_Facet()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.FacetType" containment="true"
-	 *        extendedMetaData="kind='element' name='facet' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getFacet();
-
-    /**
-	 * Returns the value of the '<em><b>Attribute</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Attribute</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>Attribute</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getComponentType_Attribute()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.AttributeType" containment="true"
-	 *        extendedMetaData="kind='element' name='attribute' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getAttribute();
-
-    /**
-	 * Returns the value of the '<em><b>Property</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Property</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>Property</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getComponentType_Property()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.PropertyType" containment="true"
-	 *        extendedMetaData="kind='element' name='property' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getProperty();
-
-    /**
-	 * Returns the value of the '<em><b>Component Extension</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ComponentExtensionType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Component Extension</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>Component Extension</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getComponentType_ComponentExtension()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ComponentExtensionType" containment="true"
-	 *        extendedMetaData="kind='element' name='component-extension' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getComponentExtension();
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getComponentType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ComponentType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ComponentTypeType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ComponentTypeType.java
deleted file mode 100644
index be947b9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ComponentTypeType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Component Type Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentTypeType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentTypeType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getComponentTypeType()
- * @model extendedMetaData="name='component-type_._type' kind='simple'"
- * @generated
- */
-public interface ComponentTypeType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getComponentTypeType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentTypeType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getComponentTypeType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentTypeType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ComponentTypeType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ConverterClassType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ConverterClassType.java
deleted file mode 100644
index f2b2dd2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ConverterClassType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Converter Class Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterClassType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterClassType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getConverterClassType()
- * @model extendedMetaData="name='converter-class_._type' kind='simple'"
- * @generated
- */
-public interface ConverterClassType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getConverterClassType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterClassType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getConverterClassType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterClassType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ConverterClassType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ConverterExtensionType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ConverterExtensionType.java
deleted file mode 100644
index 018aade..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ConverterExtensionType.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Converter Extension Type</b></em>'.
- * <!-- end-user-doc -->
- *
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getConverterExtensionType()
- * @model extendedMetaData="name='converter-extension_._type'"
- * @generated
- */
-public interface ConverterExtensionType extends ExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-} // ConverterExtensionType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ConverterForClassType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ConverterForClassType.java
deleted file mode 100644
index 90348e7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ConverterForClassType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Converter For Class Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterForClassType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterForClassType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getConverterForClassType()
- * @model extendedMetaData="name='converter-for-class_._type' kind='simple'"
- * @generated
- */
-public interface ConverterForClassType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getConverterForClassType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterForClassType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getConverterForClassType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterForClassType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ConverterForClassType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ConverterIdType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ConverterIdType.java
deleted file mode 100644
index 2adfd4e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ConverterIdType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Converter Id Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterIdType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterIdType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getConverterIdType()
- * @model extendedMetaData="name='converter-id_._type' kind='simple'"
- * @generated
- */
-public interface ConverterIdType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getConverterIdType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterIdType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getConverterIdType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterIdType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ConverterIdType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ConverterType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ConverterType.java
deleted file mode 100644
index 90eba92..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ConverterType.java
+++ /dev/null
@@ -1,260 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Converter Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getConverterId <em>Converter Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getConverterForClass <em>Converter For Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getConverterClass <em>Converter Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getAttribute <em>Attribute</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getProperty <em>Property</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getConverterExtension <em>Converter Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getConverterType()
- * @model extendedMetaData="name='converter_._type' kind='elementOnly'"
- * @generated
- */
-public interface ConverterType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Description</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Description</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>Description</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getConverterType_Description()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DescriptionType" containment="true"
-	 *        extendedMetaData="kind='element' name='description' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDescription();
-
-    /**
-	 * Returns the value of the '<em><b>Display Name</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Display Name</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>Display Name</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getConverterType_DisplayName()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType" containment="true"
-	 *        extendedMetaData="kind='element' name='display-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDisplayName();
-
-    /**
-	 * Returns the value of the '<em><b>Icon</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.IconType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Icon</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>Icon</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getConverterType_Icon()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.IconType" containment="true"
-	 *        extendedMetaData="kind='element' name='icon' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getIcon();
-
-    /**
-	 * Returns the value of the '<em><b>Converter Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Converter Id</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Converter Id</em>' containment reference.
-	 * @see #setConverterId(ConverterIdType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getConverterType_ConverterId()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='converter-id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ConverterIdType getConverterId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getConverterId <em>Converter Id</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Converter Id</em>' containment reference.
-	 * @see #getConverterId()
-	 * @generated
-	 */
-	void setConverterId(ConverterIdType value);
-
-    /**
-	 * Returns the value of the '<em><b>Converter For Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Converter For Class</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Converter For Class</em>' containment reference.
-	 * @see #setConverterForClass(ConverterForClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getConverterType_ConverterForClass()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='converter-for-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ConverterForClassType getConverterForClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getConverterForClass <em>Converter For Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Converter For Class</em>' containment reference.
-	 * @see #getConverterForClass()
-	 * @generated
-	 */
-	void setConverterForClass(ConverterForClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Converter Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Converter Class</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Converter Class</em>' containment reference.
-	 * @see #setConverterClass(ConverterClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getConverterType_ConverterClass()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='converter-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ConverterClassType getConverterClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getConverterClass <em>Converter Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Converter Class</em>' containment reference.
-	 * @see #getConverterClass()
-	 * @generated
-	 */
-	void setConverterClass(ConverterClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Attribute</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Attribute</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>Attribute</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getConverterType_Attribute()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.AttributeType" containment="true"
-	 *        extendedMetaData="kind='element' name='attribute' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getAttribute();
-
-    /**
-	 * Returns the value of the '<em><b>Property</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Property</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>Property</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getConverterType_Property()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.PropertyType" containment="true"
-	 *        extendedMetaData="kind='element' name='property' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getProperty();
-
-    /**
-	 * Returns the value of the '<em><b>Converter Extension</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ConverterExtensionType}.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Converter Extension</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>Converter Extension</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getConverterType_ConverterExtension()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ConverterExtensionType" containment="true"
-	 *        extendedMetaData="kind='element' name='converter-extension' namespace='##targetNamespace'"
-	 * @generated
-	 */
-    EList getConverterExtension();
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getConverterType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ConverterType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DefaultLocaleType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DefaultLocaleType.java
deleted file mode 100644
index c58b3f2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DefaultLocaleType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Default Locale Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultLocaleType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultLocaleType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDefaultLocaleType()
- * @model extendedMetaData="name='default-locale_._type' kind='simple'"
- * @generated
- */
-public interface DefaultLocaleType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDefaultLocaleType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultLocaleType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDefaultLocaleType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultLocaleType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // DefaultLocaleType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DefaultRenderKitIdType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DefaultRenderKitIdType.java
deleted file mode 100644
index 3f9ddda..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DefaultRenderKitIdType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Default Render Kit Id Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultRenderKitIdType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultRenderKitIdType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDefaultRenderKitIdType()
- * @model extendedMetaData="name='default-render-kit-id_._type' kind='simple'"
- * @generated
- */
-public interface DefaultRenderKitIdType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDefaultRenderKitIdType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultRenderKitIdType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDefaultRenderKitIdType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultRenderKitIdType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // DefaultRenderKitIdType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DefaultValidatorsType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DefaultValidatorsType.java
deleted file mode 100644
index 18d4e8a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DefaultValidatorsType.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Default Validators Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValidatorsType#getValidatorId <em>Validator Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValidatorsType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDefaultValidatorsType()
- * @model extendedMetaData="name='default-validators_._type' kind='elementOnly'"
- * @generated
- */
-public interface DefaultValidatorsType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Validator Id</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorIdType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Validator Id</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>Validator Id</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDefaultValidatorsType_ValidatorId()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ValidatorIdType" containment="true"
-	 *        extendedMetaData="kind='element' name='validator-id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getValidatorId();
-
-	/**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDefaultValidatorsType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValidatorsType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // DefaultValidatorsType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DefaultValueType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DefaultValueType.java
deleted file mode 100644
index 50950fd..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DefaultValueType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Default Value Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValueType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValueType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDefaultValueType()
- * @model extendedMetaData="name='default-value_._type' kind='simple'"
- * @generated
- */
-public interface DefaultValueType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDefaultValueType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValueType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDefaultValueType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValueType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // DefaultValueType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DescriptionType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DescriptionType.java
deleted file mode 100644
index 004c2aa..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DescriptionType.java
+++ /dev/null
@@ -1,123 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Description Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType#getLang <em>Lang</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDescriptionType()
- * @model extendedMetaData="name='description_._type' kind='simple'"
- * @generated
- */
-public interface DescriptionType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDescriptionType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Lang</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Lang</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Lang</em>' attribute.
-	 * @see #setLang(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDescriptionType_Lang()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.Language"
-	 *        extendedMetaData="kind='attribute' name='lang' namespace='http://www.w3.org/XML/1998/namespace'"
-	 * @generated
-	 */
-	String getLang();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType#getLang <em>Lang</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Lang</em>' attribute.
-	 * @see #getLang()
-	 * @generated
-	 */
-	void setLang(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDescriptionType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // DescriptionType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DisplayNameType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DisplayNameType.java
deleted file mode 100644
index 0e47ccc..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DisplayNameType.java
+++ /dev/null
@@ -1,123 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Display Name Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType#getLang <em>Lang</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDisplayNameType()
- * @model extendedMetaData="name='display-name_._type' kind='simple'"
- * @generated
- */
-public interface DisplayNameType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDisplayNameType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Lang</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Lang</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Lang</em>' attribute.
-	 * @see #setLang(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDisplayNameType_Lang()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.Language"
-	 *        extendedMetaData="kind='attribute' name='lang' namespace='http://www.w3.org/XML/1998/namespace'"
-	 * @generated
-	 */
-	String getLang();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType#getLang <em>Lang</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Lang</em>' attribute.
-	 * @see #getLang()
-	 * @generated
-	 */
-	void setLang(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDisplayNameType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // DisplayNameType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DocumentRoot.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DocumentRoot.java
deleted file mode 100644
index d6fe20b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DocumentRoot.java
+++ /dev/null
@@ -1,3208 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EMap;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.util.FeatureMap;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Document Root</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getMixed <em>Mixed</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getXMLNSPrefixMap <em>XMLNS Prefix Map</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getXSISchemaLocation <em>XSI Schema Location</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getAbsoluteOrdering <em>Absolute Ordering</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getActionListener <em>Action Listener</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getApplication <em>Application</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getApplicationFactory <em>Application Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getAttribute <em>Attribute</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getAttributeClass <em>Attribute Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getAttributeExtension <em>Attribute Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getAttributeName <em>Attribute Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getBehavior <em>Behavior</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getBehaviorClass <em>Behavior Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getBehaviorId <em>Behavior Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getBehaviorExtension <em>Behavior Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getComponent <em>Component</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getComponentClass <em>Component Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getComponentExtension <em>Component Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getComponentFamily <em>Component Family</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getComponentType <em>Component Type</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getConverter <em>Converter</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getConverterClass <em>Converter Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getConverterForClass <em>Converter For Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getConverterId <em>Converter Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDefaultLocale <em>Default Locale</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDefaultRenderKitId <em>Default Render Kit Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDefaultValidators <em>Default Validators</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDefaultValue <em>Default Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getExceptionHandlerFactory <em>Exception Handler Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getExternalContextFactory <em>External Context Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFacesConfig <em>Faces Config</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFacesContextFactory <em>Faces Context Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFacet <em>Facet</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFacetExtension <em>Facet Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFacetName <em>Facet Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFactory <em>Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFromAction <em>From Action</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFromOutcome <em>From Outcome</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFromViewId <em>From View Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getIf <em>If</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getKey <em>Key</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getKeyClass <em>Key Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getLargeIcon <em>Large Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getLifecycle <em>Lifecycle</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getLifecycleFactory <em>Lifecycle Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getListEntries <em>List Entries</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getLocaleConfig <em>Locale Config</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getManagedBean <em>Managed Bean</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getManagedBeanClass <em>Managed Bean Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getManagedBeanName <em>Managed Bean Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getManagedBeanScope <em>Managed Bean Scope</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getManagedProperty <em>Managed Property</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getMapEntries <em>Map Entries</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getMapEntry <em>Map Entry</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getMessageBundle <em>Message Bundle</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getNavigationCase <em>Navigation Case</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getNavigationHandler <em>Navigation Handler</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getNavigationRule <em>Navigation Rule</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getNullValue <em>Null Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getOrdering <em>Ordering</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getOrderingOrdering <em>Ordering Ordering</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getOthers <em>Others</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPartialViewContextFactory <em>Partial View Context Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPhaseListener <em>Phase Listener</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getProperty <em>Property</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPropertyClass <em>Property Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPropertyExtension <em>Property Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPropertyName <em>Property Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPropertyResolver <em>Property Resolver</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRedirect <em>Redirect</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRedirectViewParam <em>Redirect View Param</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getReferencedBean <em>Referenced Bean</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getReferencedBeanClass <em>Referenced Bean Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getReferencedBeanName <em>Referenced Bean Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRenderer <em>Renderer</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRendererClass <em>Renderer Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRendererExtension <em>Renderer Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRendererType <em>Renderer Type</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRenderKit <em>Render Kit</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRenderKitClass <em>Render Kit Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRenderKitFactory <em>Render Kit Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRenderKitId <em>Render Kit Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getResourceHandler <em>Resource Handler</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSmallIcon <em>Small Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSourceClass <em>Source Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getStateManager <em>State Manager</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSuggestedValue <em>Suggested Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSupportedLocale <em>Supported Locale</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSystemEventClass <em>System Event Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSystemEventListener <em>System Event Listener</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSystemEventListenerClass <em>System Event Listener Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getTagHandlerDelegateFactory <em>Tag Handler Delegate Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getToViewId <em>To View Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getValidator <em>Validator</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getValidatorClass <em>Validator Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getValidatorId <em>Validator Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getValue <em>Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getValueClass <em>Value Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getVariableResolver <em>Variable Resolver</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getViewDeclarationLanguageFactory <em>View Declaration Language Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getViewHandler <em>View Handler</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getVisitContextFactory <em>Visit Context Factory</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot()
- * @model extendedMetaData="name='' kind='mixed'"
- * @generated
- */
-public interface DocumentRoot extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Mixed</b></em>' attribute list.
-	 * The list contents are of type {@link org.eclipse.emf.ecore.util.FeatureMap.Entry}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Mixed</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>Mixed</em>' attribute list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_Mixed()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.EFeatureMapEntry" many="true"
-	 *        extendedMetaData="kind='elementWildcard' name=':mixed'"
-	 * @generated
-	 */
-	FeatureMap getMixed();
-
-    /**
-	 * Returns the value of the '<em><b>XMLNS Prefix Map</b></em>' map.
-	 * The key is of type {@link java.lang.String},
-	 * and the value is of type {@link java.lang.String},
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>XMLNS Prefix Map</em>' map isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>XMLNS Prefix Map</em>' map.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_XMLNSPrefixMap()
-	 * @model mapType="org.eclipse.emf.ecore.EStringToStringMapEntry" keyType="java.lang.String" valueType="java.lang.String" transient="true"
-	 *        extendedMetaData="kind='attribute' name='xmlns:prefix'"
-	 * @generated
-	 */
-	EMap getXMLNSPrefixMap();
-
-    /**
-	 * Returns the value of the '<em><b>XSI Schema Location</b></em>' map.
-	 * The key is of type {@link java.lang.String},
-	 * and the value is of type {@link java.lang.String},
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>XSI Schema Location</em>' map isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>XSI Schema Location</em>' map.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_XSISchemaLocation()
-	 * @model mapType="org.eclipse.emf.ecore.EStringToStringMapEntry" keyType="java.lang.String" valueType="java.lang.String" transient="true"
-	 *        extendedMetaData="kind='attribute' name='xsi:schemaLocation'"
-	 * @generated
-	 */
-	EMap getXSISchemaLocation();
-
-    /**
-	 * Returns the value of the '<em><b>Absolute Ordering</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Absolute Ordering</em>' containment reference.
-	 * @see #setAbsoluteOrdering(AbsoluteOrderingType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_AbsoluteOrdering()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='absolute-ordering' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	AbsoluteOrderingType getAbsoluteOrdering();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getAbsoluteOrdering <em>Absolute Ordering</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Absolute Ordering</em>' containment reference.
-	 * @see #getAbsoluteOrdering()
-	 * @generated
-	 */
-	void setAbsoluteOrdering(AbsoluteOrderingType value);
-
-				/**
-	 * Returns the value of the '<em><b>Action Listener</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *  ==================== Subordinate
-	 *                 Elements ============================       The
-	 *                 "action-listener" element contains the fully
-	 *                 qualified class name     of the concrete ActionListener
-	 *                 implementation class that will be called     during the
-	 *                 Invoke Application phase of the request processing
-	 *                 lifecycle.     It must be of type "ClassName". 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Action Listener</em>' containment reference.
-	 * @see #setActionListener(ActionListenerType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ActionListener()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='action-listener' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ActionListenerType getActionListener();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getActionListener <em>Action Listener</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Action Listener</em>' containment reference.
-	 * @see #getActionListener()
-	 * @generated
-	 */
-	void setActionListener(ActionListenerType value);
-
-    /**
-	 * Returns the value of the '<em><b>Application</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *  ==================== Definition Elements
-	 *                 =============================       The
-	 *                 "application" element provides a mechanism to
-	 *                 define the various     per-application-singleton
-	 *                 implementation classes for a particular web
-	 *                 application that is utilizing JavaServer Faces.  For
-	 *                 nested elements     that are not specified, the JSF
-	 *                 implementation must provide a suitable     default. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Application</em>' containment reference.
-	 * @see #setApplication(ApplicationType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_Application()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='application' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ApplicationType getApplication();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getApplication <em>Application</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Application</em>' containment reference.
-	 * @see #getApplication()
-	 * @generated
-	 */
-	void setApplication(ApplicationType value);
-
-    /**
-	 * Returns the value of the '<em><b>Application Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "application-factory"
-	 *                 element contains the fully qualified class     name of
-	 *                 the concrete ApplicationFactory implementation class
-	 *                 that     will be called when
-	 *                 FactoryFinder.getFactory(APPLICATION_FACTORY) is
-	 *                 called. It must be of type "ClassName". 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Application Factory</em>' containment reference.
-	 * @see #setApplicationFactory(ApplicationFactoryType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ApplicationFactory()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='application-factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ApplicationFactoryType getApplicationFactory();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getApplicationFactory <em>Application Factory</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Application Factory</em>' containment reference.
-	 * @see #getApplicationFactory()
-	 * @generated
-	 */
-	void setApplicationFactory(ApplicationFactoryType value);
-
-    /**
-	 * Returns the value of the '<em><b>Attribute</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "attribute" element
-	 *                 represents a named, typed, value associated with     the
-	 *                 parent UIComponent via the generic attributes mechanism.
-	 *                 Attribute names must be unique within the scope of the
-	 *                 parent (or related)     component. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Attribute</em>' containment reference.
-	 * @see #setAttribute(AttributeType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_Attribute()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='attribute' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	AttributeType getAttribute();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getAttribute <em>Attribute</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Attribute</em>' containment reference.
-	 * @see #getAttribute()
-	 * @generated
-	 */
-	void setAttribute(AttributeType value);
-
-    /**
-	 * Returns the value of the '<em><b>Attribute Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "attribute-class" element represents the Java type of the value
-	 *     associated with this attribute name.  It must be of type "ClassName".
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Attribute Class</em>' containment reference.
-	 * @see #setAttributeClass(AttributeClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_AttributeClass()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='attribute-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	AttributeClassType getAttributeClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getAttributeClass <em>Attribute Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Attribute Class</em>' containment reference.
-	 * @see #getAttributeClass()
-	 * @generated
-	 */
-	void setAttributeClass(AttributeClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Attribute Extension</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *       Extension element for attribute.
-	 *                 May contain implementation     specific content. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Attribute Extension</em>' containment reference.
-	 * @see #setAttributeExtension(AttributeExtensionType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_AttributeExtension()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='attribute-extension' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	AttributeExtensionType getAttributeExtension();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getAttributeExtension <em>Attribute Extension</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Attribute Extension</em>' containment reference.
-	 * @see #getAttributeExtension()
-	 * @generated
-	 */
-	void setAttributeExtension(AttributeExtensionType value);
-
-    /**
-	 * Returns the value of the '<em><b>Attribute Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "attribute-name"
-	 *                 element represents the name under which the
-	 *                 corresponding value will be stored, in the generic
-	 *                 attributes of the     UIComponent we are related to. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Attribute Name</em>' containment reference.
-	 * @see #setAttributeName(AttributeNameType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_AttributeName()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='attribute-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	AttributeNameType getAttributeName();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getAttributeName <em>Attribute Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Attribute Name</em>' containment reference.
-	 * @see #getAttributeName()
-	 * @generated
-	 */
-	void setAttributeName(AttributeNameType value);
-
-    /**
-	 * Returns the value of the '<em><b>Behavior</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Behavior</em>' containment reference.
-	 * @see #setBehavior(BehaviorType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_Behavior()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='behavior' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	BehaviorType getBehavior();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getBehavior <em>Behavior</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Behavior</em>' containment reference.
-	 * @see #getBehavior()
-	 * @generated
-	 */
-	void setBehavior(BehaviorType value);
-
-				/**
-	 * Returns the value of the '<em><b>Behavior Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Behavior Class</em>' containment reference.
-	 * @see #setBehaviorClass(BehaviorClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_BehaviorClass()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='behavior-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	BehaviorClassType getBehaviorClass();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getBehaviorClass <em>Behavior Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Behavior Class</em>' containment reference.
-	 * @see #getBehaviorClass()
-	 * @generated
-	 */
-	void setBehaviorClass(BehaviorClassType value);
-
-				/**
-	 * Returns the value of the '<em><b>Behavior Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Behavior Id</em>' containment reference.
-	 * @see #setBehaviorId(BehaviorIdType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_BehaviorId()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='behavior-id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	BehaviorIdType getBehaviorId();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getBehaviorId <em>Behavior Id</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Behavior Id</em>' containment reference.
-	 * @see #getBehaviorId()
-	 * @generated
-	 */
-	void setBehaviorId(BehaviorIdType value);
-
-				/**
-	 * Returns the value of the '<em><b>Behavior Extension</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Behavior Extension</em>' containment reference.
-	 * @see #setBehaviorExtension(BehaviorExtensionType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_BehaviorExtension()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='behavior-extension' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	BehaviorExtensionType getBehaviorExtension();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getBehaviorExtension <em>Behavior Extension</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Behavior Extension</em>' containment reference.
-	 * @see #getBehaviorExtension()
-	 * @generated
-	 */
-	void setBehaviorExtension(BehaviorExtensionType value);
-
-				/**
-	 * Returns the value of the '<em><b>Component</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "component" element
-	 *                 represents a concrete UIComponent implementation
-	 *                 class that should be registered under the specified type
-	 *                 identifier,     along with its associated properties and
-	 *                 attributes.  Component types must     be unique within
-	 *                 the entire web application.      Nested
-	 *                 "attribute" elements identify generic
-	 *                 attributes that are recognized     by the implementation
-	 *                 logic of this component.  Nested "property"
-	 *                 elements     identify JavaBeans properties of the
-	 *                 component class that may be exposed     for manipulation
-	 *                 via tools. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Component</em>' containment reference.
-	 * @see #setComponent(ComponentType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_Component()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='component' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ComponentType getComponent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getComponent <em>Component</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Component</em>' containment reference.
-	 * @see #getComponent()
-	 * @generated
-	 */
-	void setComponent(ComponentType value);
-
-    /**
-	 * Returns the value of the '<em><b>Component Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "component-class"
-	 *                 element represents the fully qualified class name     of
-	 *                 a concrete UIComponent implementation class.  It must be
-	 *                 of     type "ClassName". 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Component Class</em>' containment reference.
-	 * @see #setComponentClass(ComponentClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ComponentClass()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='component-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ComponentClassType getComponentClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getComponentClass <em>Component Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Component Class</em>' containment reference.
-	 * @see #getComponentClass()
-	 * @generated
-	 */
-	void setComponentClass(ComponentClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Component Extension</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *       Extension element for component.
-	 *                 May contain implementation     specific content. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Component Extension</em>' containment reference.
-	 * @see #setComponentExtension(ComponentExtensionType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ComponentExtension()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='component-extension' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ComponentExtensionType getComponentExtension();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getComponentExtension <em>Component Extension</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Component Extension</em>' containment reference.
-	 * @see #getComponentExtension()
-	 * @generated
-	 */
-	void setComponentExtension(ComponentExtensionType value);
-
-    /**
-	 * Returns the value of the '<em><b>Component Family</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "component-family" element represents the component family for
-	 *     which the Renderer represented by the parent "renderer" element will be
-	 *     used.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Component Family</em>' containment reference.
-	 * @see #setComponentFamily(ComponentFamilyType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ComponentFamily()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='component-family' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ComponentFamilyType getComponentFamily();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getComponentFamily <em>Component Family</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Component Family</em>' containment reference.
-	 * @see #getComponentFamily()
-	 * @generated
-	 */
-	void setComponentFamily(ComponentFamilyType value);
-
-    /**
-	 * Returns the value of the '<em><b>Component Type</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "component-type"
-	 *                 element represents the name under which the
-	 *                 corresponding UIComponent class should be registered. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Component Type</em>' containment reference.
-	 * @see #setComponentType(ComponentTypeType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ComponentType()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='component-type' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ComponentTypeType getComponentType();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getComponentType <em>Component Type</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Component Type</em>' containment reference.
-	 * @see #getComponentType()
-	 * @generated
-	 */
-	void setComponentType(ComponentTypeType value);
-
-    /**
-	 * Returns the value of the '<em><b>Converter</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "converter" element
-	 *                 represents a concrete Converter implementation     class
-	 *                 that should be registered under the specified converter
-	 *                 identifier.     Converter identifiers must be unique
-	 *                 within the entire web application.      Nested
-	 *                 "attribute" elements identify generic
-	 *                 attributes that may be     configured on the
-	 *                 corresponding UIComponent in order to affect the
-	 *                 operation of the Converter.  Nested "property"
-	 *                 elements identify JavaBeans     properties of the
-	 *                 Converter implementation class that may be configured
-	 *                 to affect the operation of the Converter. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Converter</em>' containment reference.
-	 * @see #setConverter(ConverterType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_Converter()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='converter' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ConverterType getConverter();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getConverter <em>Converter</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Converter</em>' containment reference.
-	 * @see #getConverter()
-	 * @generated
-	 */
-	void setConverter(ConverterType value);
-
-    /**
-	 * Returns the value of the '<em><b>Converter Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "converter-class" element represents the fully qualified class name
-	 *     of a concrete Converter implementation class.  It must be of
-	 *     type "ClassName".
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Converter Class</em>' containment reference.
-	 * @see #setConverterClass(ConverterClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ConverterClass()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='converter-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ConverterClassType getConverterClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getConverterClass <em>Converter Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Converter Class</em>' containment reference.
-	 * @see #getConverterClass()
-	 * @generated
-	 */
-	void setConverterClass(ConverterClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Converter For Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "converter-for-class" element represents the fully qualified class name
-	 *     for which a Converter class will be registered.  It must be of
-	 *     type "ClassName".
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Converter For Class</em>' containment reference.
-	 * @see #setConverterForClass(ConverterForClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ConverterForClass()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='converter-for-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ConverterForClassType getConverterForClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getConverterForClass <em>Converter For Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Converter For Class</em>' containment reference.
-	 * @see #getConverterForClass()
-	 * @generated
-	 */
-	void setConverterForClass(ConverterForClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Converter Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "converter-id" element represents the identifier under which the
-	 *     corresponding Converter class should be registered.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Converter Id</em>' containment reference.
-	 * @see #setConverterId(ConverterIdType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ConverterId()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='converter-id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ConverterIdType getConverterId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getConverterId <em>Converter Id</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Converter Id</em>' containment reference.
-	 * @see #getConverterId()
-	 * @generated
-	 */
-	void setConverterId(ConverterIdType value);
-
-    /**
-	 * Returns the value of the '<em><b>Default Locale</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *       The "default-locale"
-	 *                 element declares the default locale for this
-	 *                 application instance.  It must be specified as
-	 *                 :language:[_:country:[_:variant:]] without the colons,
-	 *                 for example      "ja_JP_SJIS".  The separators
-	 *                 between the segments may be '-' or
-	 *                 '_'. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Default Locale</em>' containment reference.
-	 * @see #setDefaultLocale(DefaultLocaleType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_DefaultLocale()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='default-locale' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	DefaultLocaleType getDefaultLocale();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDefaultLocale <em>Default Locale</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Default Locale</em>' containment reference.
-	 * @see #getDefaultLocale()
-	 * @generated
-	 */
-	void setDefaultLocale(DefaultLocaleType value);
-
-    /**
-	 * Returns the value of the '<em><b>Default Render Kit Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "default-render-kit-id" element allows the application to define
-	 *     a renderkit to be used other than the standard one. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Default Render Kit Id</em>' containment reference.
-	 * @see #setDefaultRenderKitId(DefaultRenderKitIdType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_DefaultRenderKitId()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='default-render-kit-id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	DefaultRenderKitIdType getDefaultRenderKitId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDefaultRenderKitId <em>Default Render Kit Id</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Default Render Kit Id</em>' containment reference.
-	 * @see #getDefaultRenderKitId()
-	 * @generated
-	 */
-	void setDefaultRenderKitId(DefaultRenderKitIdType value);
-
-    /**
-	 * Returns the value of the '<em><b>Default Validators</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Default Validators</em>' containment reference.
-	 * @see #setDefaultValidators(DefaultValidatorsType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_DefaultValidators()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='default-validators' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	DefaultValidatorsType getDefaultValidators();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDefaultValidators <em>Default Validators</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Default Validators</em>' containment reference.
-	 * @see #getDefaultValidators()
-	 * @generated
-	 */
-	void setDefaultValidators(DefaultValidatorsType value);
-
-				/**
-	 * Returns the value of the '<em><b>Default Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "default-value" contains the value for the property or attribute
-	 *     in which this element resides.  This value differs from the
-	 *     "suggested-value" in that the property or attribute must take the
-	 *     value, whereas in "suggested-value" taking the value is optional.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Default Value</em>' containment reference.
-	 * @see #setDefaultValue(DefaultValueType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_DefaultValue()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='default-value' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	DefaultValueType getDefaultValue();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDefaultValue <em>Default Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Default Value</em>' containment reference.
-	 * @see #getDefaultValue()
-	 * @generated
-	 */
-	void setDefaultValue(DefaultValueType value);
-
-    /**
-	 * Returns the value of the '<em><b>Description</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "description" element
-	 *                 contains a textual description of the element     it is
-	 *                 nested in, optionally flagged with a language code using
-	 *                 the     "xml:lang" attribute. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Description</em>' containment reference.
-	 * @see #setDescription(DescriptionType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_Description()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='description' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	DescriptionType getDescription();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDescription <em>Description</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Description</em>' containment reference.
-	 * @see #getDescription()
-	 * @generated
-	 */
-	void setDescription(DescriptionType value);
-
-    /**
-	 * Returns the value of the '<em><b>Display Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "display-name" element
-	 *                 is a short descriptive name describing the     entity
-	 *                 associated with the element it is nested in, intended to
-	 *                 be     displayed by tools, and optionally flagged with a
-	 *                 language code using     the "xml:lang"
-	 *                 attribute. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Display Name</em>' containment reference.
-	 * @see #setDisplayName(DisplayNameType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_DisplayName()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='display-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	DisplayNameType getDisplayName();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDisplayName <em>Display Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Display Name</em>' containment reference.
-	 * @see #getDisplayName()
-	 * @generated
-	 */
-	void setDisplayName(DisplayNameType value);
-
-    /**
-	 * Returns the value of the '<em><b>Exception Handler Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Exception Handler Factory</em>' containment reference.
-	 * @see #setExceptionHandlerFactory(ExceptionHandlerFactoryType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ExceptionHandlerFactory()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='exception-handler-factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ExceptionHandlerFactoryType getExceptionHandlerFactory();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getExceptionHandlerFactory <em>Exception Handler Factory</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Exception Handler Factory</em>' containment reference.
-	 * @see #getExceptionHandlerFactory()
-	 * @generated
-	 */
-	void setExceptionHandlerFactory(ExceptionHandlerFactoryType value);
-
-				/**
-	 * Returns the value of the '<em><b>External Context Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>External Context Factory</em>' containment reference.
-	 * @see #setExternalContextFactory(ExternalContextFactoryType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ExternalContextFactory()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='external-context-factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ExternalContextFactoryType getExternalContextFactory();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getExternalContextFactory <em>External Context Factory</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>External Context Factory</em>' containment reference.
-	 * @see #getExternalContextFactory()
-	 * @generated
-	 */
-	void setExternalContextFactory(ExternalContextFactoryType value);
-
-				/**
-	 * Returns the value of the '<em><b>Faces Config</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *  ==================== Top Level Elements
-	 *                 ==============================       The
-	 *                 "faces-config" element is the root of the
-	 *                 configuration information     hierarchy, and contains
-	 *                 nested elements for all of the other configuration
-	 *                 settings. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Faces Config</em>' containment reference.
-	 * @see #setFacesConfig(FacesConfigType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_FacesConfig()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='faces-config' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	FacesConfigType getFacesConfig();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFacesConfig <em>Faces Config</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Faces Config</em>' containment reference.
-	 * @see #getFacesConfig()
-	 * @generated
-	 */
-	void setFacesConfig(FacesConfigType value);
-
-    /**
-	 * Returns the value of the '<em><b>Faces Context Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The
-	 *                 "faces-context-factory" element contains the
-	 *                 fully qualified     class name of the concrete
-	 *                 FacesContextFactory implementation class     that will
-	 *                 be called when
-	 *                 FactoryFinder.getFactory(FACES_CONTEXT_FACTORY) is
-	 *                 called. It must     be of type "ClassName". 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Faces Context Factory</em>' containment reference.
-	 * @see #setFacesContextFactory(FacesContextFactoryType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_FacesContextFactory()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='faces-context-factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	FacesContextFactoryType getFacesContextFactory();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFacesContextFactory <em>Faces Context Factory</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Faces Context Factory</em>' containment reference.
-	 * @see #getFacesContextFactory()
-	 * @generated
-	 */
-	void setFacesContextFactory(FacesContextFactoryType value);
-
-    /**
-	 * Returns the value of the '<em><b>Facet</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *    Define the name and other design-time information for a facet that is
-	 *    associated with a renderer or a component.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Facet</em>' containment reference.
-	 * @see #setFacet(FacetType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_Facet()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='facet' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	FacetType getFacet();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFacet <em>Facet</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Facet</em>' containment reference.
-	 * @see #getFacet()
-	 * @generated
-	 */
-	void setFacet(FacetType value);
-
-    /**
-	 * Returns the value of the '<em><b>Facet Extension</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     Extension element for facet.  May contain implementation
-	 *     specific content.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Facet Extension</em>' containment reference.
-	 * @see #setFacetExtension(FacetExtensionType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_FacetExtension()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='facet-extension' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	FacetExtensionType getFacetExtension();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFacetExtension <em>Facet Extension</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Facet Extension</em>' containment reference.
-	 * @see #getFacetExtension()
-	 * @generated
-	 */
-	void setFacetExtension(FacetExtensionType value);
-
-    /**
-	 * Returns the value of the '<em><b>Facet Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "facet-name" element represents the facet name under which a
-	 *     UIComponent will be added to its parent.  It must be of type
-	 *     "Identifier".
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Facet Name</em>' containment reference.
-	 * @see #setFacetName(FacetNameType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_FacetName()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='facet-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	FacetNameType getFacetName();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFacetName <em>Facet Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Facet Name</em>' containment reference.
-	 * @see #getFacetName()
-	 * @generated
-	 */
-	void setFacetName(FacetNameType value);
-
-    /**
-	 * Returns the value of the '<em><b>Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "factory" element
-	 *                 provides a mechanism to define the various     Factories
-	 *                 that comprise parts of the implementation of JavaServer
-	 *                 Faces.  For nested elements that are not specified, the
-	 *                 JSF     implementation must provide a suitable default. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Factory</em>' containment reference.
-	 * @see #setFactory(FactoryType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_Factory()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	FactoryType getFactory();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFactory <em>Factory</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Factory</em>' containment reference.
-	 * @see #getFactory()
-	 * @generated
-	 */
-	void setFactory(FactoryType value);
-
-    /**
-	 * Returns the value of the '<em><b>From Action</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "from-action" element contains an action reference expression
-	 *     that must have been executed (by the default ActionListener for handling
-	 *     application level events) in order to select this navigation rule.  If
-	 *     not specified, this rule will be relevant no matter which action reference
-	 *     was executed (or if no action reference was executed).
-	 * 
-	 *     This value must be of type "Action".
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>From Action</em>' containment reference.
-	 * @see #setFromAction(FromActionType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_FromAction()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='from-action' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	FromActionType getFromAction();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFromAction <em>From Action</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>From Action</em>' containment reference.
-	 * @see #getFromAction()
-	 * @generated
-	 */
-	void setFromAction(FromActionType value);
-
-    /**
-	 * Returns the value of the '<em><b>From Outcome</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "from-outcome" element contains a logical outcome string returned
-	 *     by the execution of an application action method selected via an
-	 *     "actionRef" property (or a literal value specified by an "action"
-	 *     property) of a UICommand component.  If specified, this rule will be
-	 *     relevant only if the outcome value matches this element's value.  If
-	 *     not specified, this rule will be relevant no matter what the outcome
-	 *     value was.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>From Outcome</em>' containment reference.
-	 * @see #setFromOutcome(FromOutcomeType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_FromOutcome()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='from-outcome' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	FromOutcomeType getFromOutcome();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFromOutcome <em>From Outcome</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>From Outcome</em>' containment reference.
-	 * @see #getFromOutcome()
-	 * @generated
-	 */
-	void setFromOutcome(FromOutcomeType value);
-
-    /**
-	 * Returns the value of the '<em><b>From View Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "from-view-id" element contains the view identifier of the view
-	 *     for which the containing navigation rule is relevant.  If no
-	 *     "from-view" element is specified, this rule applies to navigation
-	 *     decisions on all views.  If this element is not specified, a value
-	 *     of "*" is assumed, meaning that this navigation rule applies to all
-	 *     views.
-	 * 
-	 *     This value must be of type "ViewIdPattern".
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>From View Id</em>' containment reference.
-	 * @see #setFromViewId(FromViewIdType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_FromViewId()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='from-view-id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	FromViewIdType getFromViewId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFromViewId <em>From View Id</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>From View Id</em>' containment reference.
-	 * @see #getFromViewId()
-	 * @generated
-	 */
-	void setFromViewId(FromViewIdType value);
-
-    /**
-	 * Returns the value of the '<em><b>Icon</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "icon" element
-	 *                 contains "small-icon" and
-	 *                 "large-icon" elements that     specify the
-	 *                 resoruce paths for small and large GIF or JPG icon
-	 *                 images     used to represent the parent element in a GUI
-	 *                 tool. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Icon</em>' containment reference.
-	 * @see #setIcon(IconType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_Icon()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='icon' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	IconType getIcon();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getIcon <em>Icon</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Icon</em>' containment reference.
-	 * @see #getIcon()
-	 * @generated
-	 */
-	void setIcon(IconType value);
-
-    /**
-	 * Returns the value of the '<em><b>If</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>If</em>' containment reference.
-	 * @see #setIf(IfType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_If()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='if' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	IfType getIf();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getIf <em>If</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>If</em>' containment reference.
-	 * @see #getIf()
-	 * @generated
-	 */
-	void setIf(IfType value);
-
-				/**
-	 * Returns the value of the '<em><b>Key</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "key" element is the String representation of a map key that
-	 *     will be stored in a managed property of type java.util.Map.  
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Key</em>' containment reference.
-	 * @see #setKey(KeyType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_Key()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='key' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	KeyType getKey();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getKey <em>Key</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Key</em>' containment reference.
-	 * @see #getKey()
-	 * @generated
-	 */
-	void setKey(KeyType value);
-
-    /**
-	 * Returns the value of the '<em><b>Key Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "key-class" element defines the Java type to which each "key"
-	 *     element in a set of "map-entry" elements will be converted to.  It
-	 *     must be of type "ClassName".  If omitted, "java.lang.String"
-	 *     is assumed.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Key Class</em>' containment reference.
-	 * @see #setKeyClass(KeyClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_KeyClass()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='key-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	KeyClassType getKeyClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getKeyClass <em>Key Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Key Class</em>' containment reference.
-	 * @see #getKeyClass()
-	 * @generated
-	 */
-	void setKeyClass(KeyClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Large Icon</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "large-icon" element contains the resource path to a large (32x32)
-	 *     icon image.  The image may be in either GIF or JPG format.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Large Icon</em>' containment reference.
-	 * @see #setLargeIcon(LargeIconType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_LargeIcon()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='large-icon' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	LargeIconType getLargeIcon();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getLargeIcon <em>Large Icon</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Large Icon</em>' containment reference.
-	 * @see #getLargeIcon()
-	 * @generated
-	 */
-	void setLargeIcon(LargeIconType value);
-
-    /**
-	 * Returns the value of the '<em><b>Lifecycle</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "lifecycle" element
-	 *                 provides a mechanism to specify     modifications to the
-	 *                 behaviour of the default Lifecycle     implementation
-	 *                 for this web application. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Lifecycle</em>' containment reference.
-	 * @see #setLifecycle(LifecycleType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_Lifecycle()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='lifecycle' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	LifecycleType getLifecycle();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getLifecycle <em>Lifecycle</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Lifecycle</em>' containment reference.
-	 * @see #getLifecycle()
-	 * @generated
-	 */
-	void setLifecycle(LifecycleType value);
-
-    /**
-	 * Returns the value of the '<em><b>Lifecycle Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "lifecycle-factory"
-	 *                 element contains the fully qualified class name     of
-	 *                 the concrete LifecycleFactory implementation class that
-	 *                 will be called     when
-	 *                 FactoryFinder.getFactory(LIFECYCLE_FACTORY) is called.
-	 *                 It must be      of type "ClassName". 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Lifecycle Factory</em>' containment reference.
-	 * @see #setLifecycleFactory(LifecycleFactoryType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_LifecycleFactory()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='lifecycle-factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	LifecycleFactoryType getLifecycleFactory();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getLifecycleFactory <em>Lifecycle Factory</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Lifecycle Factory</em>' containment reference.
-	 * @see #getLifecycleFactory()
-	 * @generated
-	 */
-	void setLifecycleFactory(LifecycleFactoryType value);
-
-    /**
-	 * Returns the value of the '<em><b>List Entries</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "list-entries" element
-	 *                 represents a set of initialization     elements for a
-	 *                 managed property that is a java.util.List or an
-	 *                 array.  In the former case, the "value-class"
-	 *                 element can optionally     be used to declare the Java
-	 *                 type to which each value should be     converted before
-	 *                 adding it to the Collection. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>List Entries</em>' containment reference.
-	 * @see #setListEntries(ListEntriesType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ListEntries()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='list-entries' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ListEntriesType getListEntries();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getListEntries <em>List Entries</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>List Entries</em>' containment reference.
-	 * @see #getListEntries()
-	 * @generated
-	 */
-	void setListEntries(ListEntriesType value);
-
-    /**
-	 * Returns the value of the '<em><b>Locale Config</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *       The "locale-config"
-	 *                 element allows the app developer to declare the
-	 *                 supported locales for this application.   
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Locale Config</em>' containment reference.
-	 * @see #setLocaleConfig(LocaleConfigType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_LocaleConfig()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='locale-config' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	LocaleConfigType getLocaleConfig();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getLocaleConfig <em>Locale Config</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Locale Config</em>' containment reference.
-	 * @see #getLocaleConfig()
-	 * @generated
-	 */
-	void setLocaleConfig(LocaleConfigType value);
-
-    /**
-	 * Returns the value of the '<em><b>Managed Bean</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "managed-bean" element
-	 *                 represents a JavaBean, of a particular class,     that
-	 *                 will be dynamically instantiated at runtime (by the
-	 *                 default     VariableResolver implementation) if it is
-	 *                 referenced as the first element     of a value reference
-	 *                 expression, and no corresponding bean can be
-	 *                 identified in any scope.  In addition to the creation of
-	 *                 the managed bean,     and the optional storing of it
-	 *                 into the specified scope, the nested
-	 *                 managed-property elements can be used to initialize the
-	 *                 contents of     settable JavaBeans properties of the
-	 *                 created instance. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Managed Bean</em>' containment reference.
-	 * @see #setManagedBean(ManagedBeanType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ManagedBean()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='managed-bean' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ManagedBeanType getManagedBean();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getManagedBean <em>Managed Bean</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Managed Bean</em>' containment reference.
-	 * @see #getManagedBean()
-	 * @generated
-	 */
-	void setManagedBean(ManagedBeanType value);
-
-    /**
-	 * Returns the value of the '<em><b>Managed Bean Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "managed-bean-class" element represents the fully qualified class
-	 *     name of the Java class that will be used to instantiate a new instance
-	 *     if creation of the specified managed bean is requested.  It must be of
-	 *     type "ClassName".
-	 * 
-	 *     The specified class must conform to standard JavaBeans conventions.
-	 *     In particular, it must have a public zero-arguments constructor, and
-	 *     zero or more public property setters.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Managed Bean Class</em>' containment reference.
-	 * @see #setManagedBeanClass(ManagedBeanClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ManagedBeanClass()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='managed-bean-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ManagedBeanClassType getManagedBeanClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getManagedBeanClass <em>Managed Bean Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Managed Bean Class</em>' containment reference.
-	 * @see #getManagedBeanClass()
-	 * @generated
-	 */
-	void setManagedBeanClass(ManagedBeanClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Managed Bean Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "managed-bean-name" element represents the attribute name under
-	 *     which a managed bean will be searched for, as well as stored (unless
-	 *     the "managed-bean-scope" value is "none").  It must be of type
-	 *     "Identifier".
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Managed Bean Name</em>' containment reference.
-	 * @see #setManagedBeanName(ManagedBeanNameType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ManagedBeanName()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='managed-bean-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ManagedBeanNameType getManagedBeanName();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getManagedBeanName <em>Managed Bean Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Managed Bean Name</em>' containment reference.
-	 * @see #getManagedBeanName()
-	 * @generated
-	 */
-	void setManagedBeanName(ManagedBeanNameType value);
-
-    /**
-	 * Returns the value of the '<em><b>Managed Bean Scope</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "managed-bean-scope" element represents the scope into which a newly
-	 *     created instance of the specified managed bean will be stored (unless
-	 *     the value is "none").  It must be of type "ScopeOrNone".
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Managed Bean Scope</em>' containment reference.
-	 * @see #setManagedBeanScope(ManagedBeanScopeType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ManagedBeanScope()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='managed-bean-scope' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ManagedBeanScopeType getManagedBeanScope();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getManagedBeanScope <em>Managed Bean Scope</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Managed Bean Scope</em>' containment reference.
-	 * @see #getManagedBeanScope()
-	 * @generated
-	 */
-	void setManagedBeanScope(ManagedBeanScopeType value);
-
-    /**
-	 * Returns the value of the '<em><b>Managed Property</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "managed-property"
-	 *                 element represents an individual property of a
-	 *                 managed bean that will be configured to the specified
-	 *                 value (or value set)     if the corresponding managed
-	 *                 bean is automatically created. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Managed Property</em>' containment reference.
-	 * @see #setManagedProperty(ManagedPropertyType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ManagedProperty()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='managed-property' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ManagedPropertyType getManagedProperty();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getManagedProperty <em>Managed Property</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Managed Property</em>' containment reference.
-	 * @see #getManagedProperty()
-	 * @generated
-	 */
-	void setManagedProperty(ManagedPropertyType value);
-
-    /**
-	 * Returns the value of the '<em><b>Map Entries</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "map-entries' element
-	 *                 represents a set of key-entry pairs that     will be
-	 *                 added to the computed value of a managed property of
-	 *                 type     java.util.Map.  In addition, the Java class
-	 *                 types of the key and entry     values may be optionally
-	 *                 declared. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Map Entries</em>' containment reference.
-	 * @see #setMapEntries(MapEntriesType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_MapEntries()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='map-entries' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	MapEntriesType getMapEntries();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getMapEntries <em>Map Entries</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Map Entries</em>' containment reference.
-	 * @see #getMapEntries()
-	 * @generated
-	 */
-	void setMapEntries(MapEntriesType value);
-
-    /**
-	 * Returns the value of the '<em><b>Map Entry</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "map-entry" element
-	 *                 reprsents a single key-entry pair that     will be added
-	 *                 to the computed value of a managed property of type
-	 *                 java.util.Map. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Map Entry</em>' containment reference.
-	 * @see #setMapEntry(MapEntryType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_MapEntry()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='map-entry' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	MapEntryType getMapEntry();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getMapEntry <em>Map Entry</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Map Entry</em>' containment reference.
-	 * @see #getMapEntry()
-	 * @generated
-	 */
-	void setMapEntry(MapEntryType value);
-
-    /**
-	 * Returns the value of the '<em><b>Message Bundle</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The base name of a resource bundle
-	 *                 representing the message resources     for this
-	 *                 application.  See the JavaDocs for the
-	 *                 "java.util.ResourceBundle"     class for more
-	 *                 information on the syntax of resource bundle names. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Message Bundle</em>' containment reference.
-	 * @see #setMessageBundle(MessageBundleType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_MessageBundle()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='message-bundle' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	MessageBundleType getMessageBundle();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getMessageBundle <em>Message Bundle</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Message Bundle</em>' containment reference.
-	 * @see #getMessageBundle()
-	 * @generated
-	 */
-	void setMessageBundle(MessageBundleType value);
-
-    /**
-	 * Returns the value of the '<em><b>Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Name</em>' containment reference.
-	 * @see #setName(NameType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_Name()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	NameType getName();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getName <em>Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Name</em>' containment reference.
-	 * @see #getName()
-	 * @generated
-	 */
-	void setName(NameType value);
-
-				/**
-	 * Returns the value of the '<em><b>Navigation Case</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "navigation-case"
-	 *                 element describes a particular combination of
-	 *                 conditions that must match for this case to be executed,
-	 *                 and the     view id of the component tree that should be
-	 *                 selected next. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Navigation Case</em>' containment reference.
-	 * @see #setNavigationCase(NavigationCaseType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_NavigationCase()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='navigation-case' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	NavigationCaseType getNavigationCase();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getNavigationCase <em>Navigation Case</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Navigation Case</em>' containment reference.
-	 * @see #getNavigationCase()
-	 * @generated
-	 */
-	void setNavigationCase(NavigationCaseType value);
-
-    /**
-	 * Returns the value of the '<em><b>Navigation Handler</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "navigation-handler"
-	 *                 element contains the fully qualified class name     of
-	 *                 the concrete NavigationHandler implementation class that
-	 *                 will be called     during the Invoke Application phase
-	 *                 of the request processing lifecycle,     if the default
-	 *                 ActionListener (provided by the JSF implementation) is
-	 *                 used.     It must be of type "ClassName". 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Navigation Handler</em>' containment reference.
-	 * @see #setNavigationHandler(NavigationHandlerType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_NavigationHandler()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='navigation-handler' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	NavigationHandlerType getNavigationHandler();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getNavigationHandler <em>Navigation Handler</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Navigation Handler</em>' containment reference.
-	 * @see #getNavigationHandler()
-	 * @generated
-	 */
-	void setNavigationHandler(NavigationHandlerType value);
-
-    /**
-	 * Returns the value of the '<em><b>Navigation Rule</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "navigation-rule"
-	 *                 element represents an individual decision rule     that
-	 *                 will be utilized by the default NavigationHandler
-	 *                 implementation to make decisions on what view should be
-	 *                 displayed     next, based on the view id being
-	 *                 processed. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Navigation Rule</em>' containment reference.
-	 * @see #setNavigationRule(NavigationRuleType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_NavigationRule()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='navigation-rule' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	NavigationRuleType getNavigationRule();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getNavigationRule <em>Navigation Rule</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Navigation Rule</em>' containment reference.
-	 * @see #getNavigationRule()
-	 * @generated
-	 */
-	void setNavigationRule(NavigationRuleType value);
-
-    /**
-	 * Returns the value of the '<em><b>Null Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "null-value" element
-	 *                 indicates that the managed property in which we     are
-	 *                 nested will be explicitly set to null if our managed
-	 *                 bean is     automatically created.  This is different
-	 *                 from omitting the managed     property element entirely,
-	 *                 which will cause no property setter to be     called for
-	 *                 this property.      The "null-value" element
-	 *                 can only be used when the associated
-	 *                 "property-class" identifies a Java class, not
-	 *                 a Java primitive. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Null Value</em>' containment reference.
-	 * @see #setNullValue(NullValueType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_NullValue()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='null-value' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	NullValueType getNullValue();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getNullValue <em>Null Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Null Value</em>' containment reference.
-	 * @see #getNullValue()
-	 * @generated
-	 */
-	void setNullValue(NullValueType value);
-
-    /**
-	 * Returns the value of the '<em><b>Ordering</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Ordering</em>' containment reference.
-	 * @see #setOrdering(OrderingType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_Ordering()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='ordering' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	OrderingType getOrdering();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getOrdering <em>Ordering</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Ordering</em>' containment reference.
-	 * @see #getOrdering()
-	 * @generated
-	 */
-	void setOrdering(OrderingType value);
-
-				/**
-	 * Returns the value of the '<em><b>Ordering Ordering</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Ordering Ordering</em>' containment reference.
-	 * @see #setOrderingOrdering(OrderingOrderingType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_OrderingOrdering()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='ordering-ordering' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	OrderingOrderingType getOrderingOrdering();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getOrderingOrdering <em>Ordering Ordering</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Ordering Ordering</em>' containment reference.
-	 * @see #getOrderingOrdering()
-	 * @generated
-	 */
-	void setOrderingOrdering(OrderingOrderingType value);
-
-				/**
-	 * Returns the value of the '<em><b>Others</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Others</em>' containment reference.
-	 * @see #setOthers(OrderingOthersType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_Others()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='others' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	OrderingOthersType getOthers();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getOthers <em>Others</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Others</em>' containment reference.
-	 * @see #getOthers()
-	 * @generated
-	 */
-	void setOthers(OrderingOthersType value);
-
-				/**
-	 * Returns the value of the '<em><b>Partial View Context Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Partial View Context Factory</em>' containment reference.
-	 * @see #setPartialViewContextFactory(PartialViewContextFactoryType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_PartialViewContextFactory()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='partial-view-context-factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	PartialViewContextFactoryType getPartialViewContextFactory();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPartialViewContextFactory <em>Partial View Context Factory</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Partial View Context Factory</em>' containment reference.
-	 * @see #getPartialViewContextFactory()
-	 * @generated
-	 */
-	void setPartialViewContextFactory(PartialViewContextFactoryType value);
-
-				/**
-	 * Returns the value of the '<em><b>Phase Listener</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *  The "phase-listener" element
-	 *                 contains the fully qualified class name of the concrete
-	 *                 PhaseListener implementation class that will be
-	 *                 registered on the Lifecycle. It must be of type
-	 *                 "ClassName". 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Phase Listener</em>' containment reference.
-	 * @see #setPhaseListener(PhaseListenerType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_PhaseListener()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='phase-listener' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	PhaseListenerType getPhaseListener();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPhaseListener <em>Phase Listener</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Phase Listener</em>' containment reference.
-	 * @see #getPhaseListener()
-	 * @generated
-	 */
-	void setPhaseListener(PhaseListenerType value);
-
-    /**
-	 * Returns the value of the '<em><b>Property</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "property" element
-	 *                 represents a JavaBean property of the Java class
-	 *                 represented by our parent element.      Property names
-	 *                 must be unique within the scope of the Java class
-	 *                 that is represented by the parent element, and must
-	 *                 correspond to     property names that will be recognized
-	 *                 when performing introspection     against that class via
-	 *                 java.beans.Introspector. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Property</em>' containment reference.
-	 * @see #setProperty(PropertyType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_Property()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='property' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	PropertyType getProperty();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getProperty <em>Property</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Property</em>' containment reference.
-	 * @see #getProperty()
-	 * @generated
-	 */
-	void setProperty(PropertyType value);
-
-    /**
-	 * Returns the value of the '<em><b>Property Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "property-class" element represents the Java type of the value
-	 *     associated with this property name.  It must be of type "JavaType".
-	 *     If not specified, it can be inferred from existing classes; however,
-	 *     this element should be specified if the configuration file is going
-	 *     to be the source for generating the corresponding classes.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Property Class</em>' containment reference.
-	 * @see #setPropertyClass(PropertyClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_PropertyClass()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='property-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	PropertyClassType getPropertyClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPropertyClass <em>Property Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Property Class</em>' containment reference.
-	 * @see #getPropertyClass()
-	 * @generated
-	 */
-	void setPropertyClass(PropertyClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Property Extension</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *       Extension element for property.
-	 *                 May contain implementation     specific content. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Property Extension</em>' containment reference.
-	 * @see #setPropertyExtension(PropertyExtensionType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_PropertyExtension()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='property-extension' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	PropertyExtensionType getPropertyExtension();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPropertyExtension <em>Property Extension</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Property Extension</em>' containment reference.
-	 * @see #getPropertyExtension()
-	 * @generated
-	 */
-	void setPropertyExtension(PropertyExtensionType value);
-
-    /**
-	 * Returns the value of the '<em><b>Property Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "property-name" element represents the JavaBeans property name
-	 *     under which the corresponding value may be stored.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Property Name</em>' containment reference.
-	 * @see #setPropertyName(PropertyNameType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_PropertyName()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='property-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	PropertyNameType getPropertyName();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPropertyName <em>Property Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Property Name</em>' containment reference.
-	 * @see #getPropertyName()
-	 * @generated
-	 */
-	void setPropertyName(PropertyNameType value);
-
-    /**
-	 * Returns the value of the '<em><b>Property Resolver</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "property-resolver"
-	 *                 element contains the fully qualified class name     of
-	 *                 the concrete PropertyResolver implementation class that
-	 *                 will be used     during the processing of value
-	 *                 reference expressions.     It must be of type
-	 *                 "ClassName". 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Property Resolver</em>' containment reference.
-	 * @see #setPropertyResolver(PropertyResolverType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_PropertyResolver()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='property-resolver' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	PropertyResolverType getPropertyResolver();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPropertyResolver <em>Property Resolver</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Property Resolver</em>' containment reference.
-	 * @see #getPropertyResolver()
-	 * @generated
-	 */
-	void setPropertyResolver(PropertyResolverType value);
-
-    /**
-	 * Returns the value of the '<em><b>Redirect</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "redirect" element
-	 *                 indicates that navigation to the specified
-	 *                 "to-view-id" should be accomplished by
-	 *                 performing an HTTP redirect     rather than the usual
-	 *                 ViewHandler mechanisms. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Redirect</em>' containment reference.
-	 * @see #setRedirect(RedirectType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_Redirect()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='redirect' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	RedirectType getRedirect();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRedirect <em>Redirect</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Redirect</em>' containment reference.
-	 * @see #getRedirect()
-	 * @generated
-	 */
-	void setRedirect(RedirectType value);
-
-    /**
-	 * Returns the value of the '<em><b>Redirect View Param</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Redirect View Param</em>' containment reference.
-	 * @see #setRedirectViewParam(RedirectViewParamType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_RedirectViewParam()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='view-param' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	RedirectViewParamType getRedirectViewParam();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRedirectViewParam <em>Redirect View Param</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Redirect View Param</em>' containment reference.
-	 * @see #getRedirectViewParam()
-	 * @generated
-	 */
-	void setRedirectViewParam(RedirectViewParamType value);
-
-				/**
-	 * Returns the value of the '<em><b>Referenced Bean</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "referenced-bean"
-	 *                 element represents at design time the promise     that a
-	 *                 Java object of the specified type will exist at runtime
-	 *                 in some     scope, under the specified key.  This can be
-	 *                 used by design time tools     to construct user
-	 *                 interface dialogs based on the properties of the
-	 *                 specified class.  The presence or absence of a
-	 *                 referenced bean     element has no impact on the
-	 *                 JavaServer Faces runtime environment     inside a web
-	 *                 application. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Referenced Bean</em>' containment reference.
-	 * @see #setReferencedBean(ReferencedBeanType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ReferencedBean()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='referenced-bean' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ReferencedBeanType getReferencedBean();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getReferencedBean <em>Referenced Bean</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Referenced Bean</em>' containment reference.
-	 * @see #getReferencedBean()
-	 * @generated
-	 */
-	void setReferencedBean(ReferencedBeanType value);
-
-    /**
-	 * Returns the value of the '<em><b>Referenced Bean Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "referenced-bean-class" element represents the fully qualified class
-	 *     name of the Java class (either abstract or concrete) or Java interface
-	 *     implemented by the corresponding referenced bean.  It must be of type
-	 *     "ClassName".
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Referenced Bean Class</em>' containment reference.
-	 * @see #setReferencedBeanClass(ReferencedBeanClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ReferencedBeanClass()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='referenced-bean-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ReferencedBeanClassType getReferencedBeanClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getReferencedBeanClass <em>Referenced Bean Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Referenced Bean Class</em>' containment reference.
-	 * @see #getReferencedBeanClass()
-	 * @generated
-	 */
-	void setReferencedBeanClass(ReferencedBeanClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Referenced Bean Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "referenced-bean-name" element represents the attribute name under
-	 *     which the corresponding referenced bean may be assumed to be stored,
-	 *     in one of the scopes defined by the "Scope" type.  It must be of type
-	 *     "Identifier".
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Referenced Bean Name</em>' containment reference.
-	 * @see #setReferencedBeanName(ReferencedBeanNameType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ReferencedBeanName()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='referenced-bean-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ReferencedBeanNameType getReferencedBeanName();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getReferencedBeanName <em>Referenced Bean Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Referenced Bean Name</em>' containment reference.
-	 * @see #getReferencedBeanName()
-	 * @generated
-	 */
-	void setReferencedBeanName(ReferencedBeanNameType value);
-
-    /**
-	 * Returns the value of the '<em><b>Renderer</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "renderer" element
-	 *                 represents a concrete Renderer implementation     class
-	 *                 that should be registered under the specified type
-	 *                 identifier,     in the RenderKit associated with the
-	 *                 parent render-kit element.  Renderer     types must be
-	 *                 unique within the RenderKit associated with the parent
-	 *                 "render-kit" element.      Nested
-	 *                 "attribute" elements identify generic
-	 *                 component attributes that     are recognized by this
-	 *                 renderer.  Nested "supported-component-type"
-	 *                 and     "supported-component-class" elements
-	 *                 identify supported component classes,     by their type
-	 *                 identifiers or the implementation class name,
-	 *                 respectively,     that are supported by this Renderer. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Renderer</em>' containment reference.
-	 * @see #setRenderer(RendererType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_Renderer()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='renderer' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	RendererType getRenderer();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRenderer <em>Renderer</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Renderer</em>' containment reference.
-	 * @see #getRenderer()
-	 * @generated
-	 */
-	void setRenderer(RendererType value);
-
-    /**
-	 * Returns the value of the '<em><b>Renderer Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "renderer-class" element represents the fully qualified class name
-	 *     of a concrete Renderer implementation class.  It must be of
-	 *     type "ClassName".
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Renderer Class</em>' containment reference.
-	 * @see #setRendererClass(RendererClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_RendererClass()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='renderer-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	RendererClassType getRendererClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRendererClass <em>Renderer Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Renderer Class</em>' containment reference.
-	 * @see #getRendererClass()
-	 * @generated
-	 */
-	void setRendererClass(RendererClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Renderer Extension</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *       Extension element for renderer.
-	 *                 May contain implementation     specific content. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Renderer Extension</em>' containment reference.
-	 * @see #setRendererExtension(RendererExtensionType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_RendererExtension()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='renderer-extension' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	RendererExtensionType getRendererExtension();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRendererExtension <em>Renderer Extension</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Renderer Extension</em>' containment reference.
-	 * @see #getRendererExtension()
-	 * @generated
-	 */
-	void setRendererExtension(RendererExtensionType value);
-
-    /**
-	 * Returns the value of the '<em><b>Renderer Type</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "renderer-type" element represents a renderer type identifier for the
-	 *     Renderer represented by the parent "renderer" element.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Renderer Type</em>' containment reference.
-	 * @see #setRendererType(RendererTypeType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_RendererType()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='renderer-type' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	RendererTypeType getRendererType();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRendererType <em>Renderer Type</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Renderer Type</em>' containment reference.
-	 * @see #getRendererType()
-	 * @generated
-	 */
-	void setRendererType(RendererTypeType value);
-
-    /**
-	 * Returns the value of the '<em><b>Render Kit</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "render-kit" element
-	 *                 represents a concrete RenderKit implementation     that
-	 *                 should be registered under the specified render-kit-id.
-	 *                 If no     render-kit-id is specified, the identifier of
-	 *                 the default RenderKit
-	 *                 (RenderKitFactory.DEFAULT_RENDER_KIT) is assumed. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Render Kit</em>' containment reference.
-	 * @see #setRenderKit(RenderKitType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_RenderKit()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='render-kit' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	RenderKitType getRenderKit();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRenderKit <em>Render Kit</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Render Kit</em>' containment reference.
-	 * @see #getRenderKit()
-	 * @generated
-	 */
-	void setRenderKit(RenderKitType value);
-
-    /**
-	 * Returns the value of the '<em><b>Render Kit Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "render-kit-class" element represents the fully qualified class name
-	 *     of a concrete RenderKit implementation class.  It must be of
-	 *     type "ClassName".
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Render Kit Class</em>' containment reference.
-	 * @see #setRenderKitClass(RenderKitClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_RenderKitClass()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='render-kit-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	RenderKitClassType getRenderKitClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRenderKitClass <em>Render Kit Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Render Kit Class</em>' containment reference.
-	 * @see #getRenderKitClass()
-	 * @generated
-	 */
-	void setRenderKitClass(RenderKitClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Render Kit Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "render-kit-factory"
-	 *                 element contains the fully qualified class name     of
-	 *                 the concrete RenderKitFactory implementation class that
-	 *                 will be called     when
-	 *                 FactoryFinder.getFactory(RENDER_KIT_FACTORY) is called.
-	 *                 It must be      of type "ClassName". 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Render Kit Factory</em>' containment reference.
-	 * @see #setRenderKitFactory(RenderKitFactoryType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_RenderKitFactory()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='render-kit-factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	RenderKitFactoryType getRenderKitFactory();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRenderKitFactory <em>Render Kit Factory</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Render Kit Factory</em>' containment reference.
-	 * @see #getRenderKitFactory()
-	 * @generated
-	 */
-	void setRenderKitFactory(RenderKitFactoryType value);
-
-    /**
-	 * Returns the value of the '<em><b>Render Kit Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "render-kit-id" element represents an identifier for the
-	 *     RenderKit represented by the parent "render-kit" element.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Render Kit Id</em>' containment reference.
-	 * @see #setRenderKitId(RenderKitIdType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_RenderKitId()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='render-kit-id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	RenderKitIdType getRenderKitId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRenderKitId <em>Render Kit Id</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Render Kit Id</em>' containment reference.
-	 * @see #getRenderKitId()
-	 * @generated
-	 */
-	void setRenderKitId(RenderKitIdType value);
-
-    /**
-	 * Returns the value of the '<em><b>Resource Handler</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Resource Handler</em>' containment reference.
-	 * @see #setResourceHandler(ResourceHandlerType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ResourceHandler()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='resource-handler' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ResourceHandlerType getResourceHandler();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getResourceHandler <em>Resource Handler</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Resource Handler</em>' containment reference.
-	 * @see #getResourceHandler()
-	 * @generated
-	 */
-	void setResourceHandler(ResourceHandlerType value);
-
-				/**
-	 * Returns the value of the '<em><b>Small Icon</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "small-icon" element contains the resource path to a small (16x16)
-	 *     icon image.  The image may be in either GIF or JPG format.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Small Icon</em>' containment reference.
-	 * @see #setSmallIcon(SmallIconType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_SmallIcon()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='small-icon' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	SmallIconType getSmallIcon();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSmallIcon <em>Small Icon</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Small Icon</em>' containment reference.
-	 * @see #getSmallIcon()
-	 * @generated
-	 */
-	void setSmallIcon(SmallIconType value);
-
-    /**
-	 * Returns the value of the '<em><b>Source Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Source Class</em>' containment reference.
-	 * @see #setSourceClass(SourceClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_SourceClass()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='source-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	SourceClassType getSourceClass();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSourceClass <em>Source Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Source Class</em>' containment reference.
-	 * @see #getSourceClass()
-	 * @generated
-	 */
-	void setSourceClass(SourceClassType value);
-
-				/**
-	 * Returns the value of the '<em><b>State Manager</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *       The "state-manager"
-	 *                 element contains the fully qualified class name     of
-	 *                 the concrete StateManager implementation class that will
-	 *                 be called     during the Restore View and Render
-	 *                 Response phases of the request     processing lifecycle.
-	 *                 The faces implementation must provide a     default
-	 *                 implementation of this class 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>State Manager</em>' containment reference.
-	 * @see #setStateManager(StateManagerType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_StateManager()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='state-manager' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	StateManagerType getStateManager();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getStateManager <em>State Manager</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>State Manager</em>' containment reference.
-	 * @see #getStateManager()
-	 * @generated
-	 */
-	void setStateManager(StateManagerType value);
-
-    /**
-	 * Returns the value of the '<em><b>Suggested Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "suggested-value" contains the value for the property or
-	 *     attribute in which this element resides.  This value is advisory
-	 *     only and is intended for tools to use when populating pallettes.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Suggested Value</em>' containment reference.
-	 * @see #setSuggestedValue(SuggestedValueType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_SuggestedValue()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='suggested-value' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	SuggestedValueType getSuggestedValue();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSuggestedValue <em>Suggested Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Suggested Value</em>' containment reference.
-	 * @see #getSuggestedValue()
-	 * @generated
-	 */
-	void setSuggestedValue(SuggestedValueType value);
-
-    /**
-	 * Returns the value of the '<em><b>Supported Locale</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *       The "supported-locale"
-	 *                 element allows authors to declare which      locales are
-	 *                 supported in this application instance.       It must be
-	 *                 specified as :language:[_:country:[_:variant:]] without
-	 *                 the colons, for example "ja_JP_SJIS".  The
-	 *                 separators between the      segments may be
-	 *                 '-' or '_'. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Supported Locale</em>' containment reference.
-	 * @see #setSupportedLocale(SupportedLocaleType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_SupportedLocale()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='supported-locale' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	SupportedLocaleType getSupportedLocale();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSupportedLocale <em>Supported Locale</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Supported Locale</em>' containment reference.
-	 * @see #getSupportedLocale()
-	 * @generated
-	 */
-	void setSupportedLocale(SupportedLocaleType value);
-
-    /**
-	 * Returns the value of the '<em><b>System Event Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>System Event Class</em>' containment reference.
-	 * @see #setSystemEventClass(SystemEventClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_SystemEventClass()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='system-event-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	SystemEventClassType getSystemEventClass();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSystemEventClass <em>System Event Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>System Event Class</em>' containment reference.
-	 * @see #getSystemEventClass()
-	 * @generated
-	 */
-	void setSystemEventClass(SystemEventClassType value);
-
-				/**
-	 * Returns the value of the '<em><b>System Event Listener</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>System Event Listener</em>' containment reference.
-	 * @see #setSystemEventListener(SystemEventListenerType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_SystemEventListener()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='system-event-listener' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	SystemEventListenerType getSystemEventListener();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSystemEventListener <em>System Event Listener</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>System Event Listener</em>' containment reference.
-	 * @see #getSystemEventListener()
-	 * @generated
-	 */
-	void setSystemEventListener(SystemEventListenerType value);
-
-				/**
-	 * Returns the value of the '<em><b>System Event Listener Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>System Event Listener Class</em>' containment reference.
-	 * @see #setSystemEventListenerClass(SystemEventListenerClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_SystemEventListenerClass()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='system-event-listener-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	SystemEventListenerClassType getSystemEventListenerClass();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSystemEventListenerClass <em>System Event Listener Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>System Event Listener Class</em>' containment reference.
-	 * @see #getSystemEventListenerClass()
-	 * @generated
-	 */
-	void setSystemEventListenerClass(SystemEventListenerClassType value);
-
-				/**
-	 * Returns the value of the '<em><b>Tag Handler Delegate Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Tag Handler Delegate Factory</em>' containment reference.
-	 * @see #setTagHandlerDelegateFactory(TagHandlerDelegateFactoryType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_TagHandlerDelegateFactory()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='tag-handler-delegate-factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	TagHandlerDelegateFactoryType getTagHandlerDelegateFactory();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getTagHandlerDelegateFactory <em>Tag Handler Delegate Factory</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Tag Handler Delegate Factory</em>' containment reference.
-	 * @see #getTagHandlerDelegateFactory()
-	 * @generated
-	 */
-	void setTagHandlerDelegateFactory(TagHandlerDelegateFactoryType value);
-
-				/**
-	 * Returns the value of the '<em><b>To View Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "to-view" element contains the view identifier of the next view
-	 *     that should be displayed if this navigation rule is matched.  It
-	 *     must be of type "ViewId".
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>To View Id</em>' containment reference.
-	 * @see #setToViewId(ToViewIdType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ToViewId()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='to-view-id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ToViewIdType getToViewId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getToViewId <em>To View Id</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>To View Id</em>' containment reference.
-	 * @see #getToViewId()
-	 * @generated
-	 */
-	void setToViewId(ToViewIdType value);
-
-    /**
-	 * Returns the value of the '<em><b>Validator</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "validator" element
-	 *                 represents a concrete Validator implementation     class
-	 *                 that should be registered under the specified validator
-	 *                 identifier.     Validator identifiers must be unique
-	 *                 within the entire web application.      Nested
-	 *                 "attribute" elements identify generic
-	 *                 attributes that may be     configured on the
-	 *                 corresponding UIComponent in order to affect the
-	 *                 operation of the Validator.  Nested "property"
-	 *                 elements identify JavaBeans     properties of the
-	 *                 Validator implementation class that may be configured
-	 *                 to affect the operation of the Validator. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Validator</em>' containment reference.
-	 * @see #setValidator(ValidatorType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_Validator()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='validator' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ValidatorType getValidator();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getValidator <em>Validator</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Validator</em>' containment reference.
-	 * @see #getValidator()
-	 * @generated
-	 */
-	void setValidator(ValidatorType value);
-
-    /**
-	 * Returns the value of the '<em><b>Validator Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "validator-class" element represents the fully qualified class name
-	 *     of a concrete Validator implementation class.  It must be of
-	 *     type "ClassName".
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Validator Class</em>' containment reference.
-	 * @see #setValidatorClass(ValidatorClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ValidatorClass()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='validator-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ValidatorClassType getValidatorClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getValidatorClass <em>Validator Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Validator Class</em>' containment reference.
-	 * @see #getValidatorClass()
-	 * @generated
-	 */
-	void setValidatorClass(ValidatorClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Validator Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "validator-id" element represents the identifier under which the
-	 *     corresponding Validator class should be registered.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Validator Id</em>' containment reference.
-	 * @see #setValidatorId(ValidatorIdType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ValidatorId()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='validator-id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ValidatorIdType getValidatorId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getValidatorId <em>Validator Id</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Validator Id</em>' containment reference.
-	 * @see #getValidatorId()
-	 * @generated
-	 */
-	void setValidatorId(ValidatorIdType value);
-
-    /**
-	 * Returns the value of the '<em><b>Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "value" element is the
-	 *                 String representation of a literal     value to which a
-	 *                 scalar managed property will be set, or a value
-	 *                 reference expression ("#{...}") that will be
-	 *                 used to calculate the     required value.  It will be
-	 *                 converted as specified for the actual     property type. 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Value</em>' containment reference.
-	 * @see #setValue(ValueType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_Value()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='value' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ValueType getValue();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getValue <em>Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Value</em>' containment reference.
-	 * @see #getValue()
-	 * @generated
-	 */
-	void setValue(ValueType value);
-
-    /**
-	 * Returns the value of the '<em><b>Value Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *     The "value-class" element defines the Java type to which each
-	 *     "value" element's value will be converted to, prior to adding it to
-	 *     the "list-entries" list for a managed property that is a
-	 *     java.util.List, or a "map-entries" map for a managed property that
-	 *     is a java.util.Map.  It must be of type "ClassName".  If omitted,
-	 *     "java.lang.String" is assumed.
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Value Class</em>' containment reference.
-	 * @see #setValueClass(ValueClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ValueClass()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='value-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ValueClassType getValueClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getValueClass <em>Value Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Value Class</em>' containment reference.
-	 * @see #getValueClass()
-	 * @generated
-	 */
-	void setValueClass(ValueClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Variable Resolver</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *      The "variable-resolver"
-	 *                 element contains the fully qualified class name     of
-	 *                 the concrete VariableResolver implementation class that
-	 *                 will be used     during the processing of value
-	 *                 reference expressions.     It must be of type
-	 *                 "ClassName". 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Variable Resolver</em>' containment reference.
-	 * @see #setVariableResolver(VariableResolverType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_VariableResolver()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='variable-resolver' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	VariableResolverType getVariableResolver();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getVariableResolver <em>Variable Resolver</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Variable Resolver</em>' containment reference.
-	 * @see #getVariableResolver()
-	 * @generated
-	 */
-	void setVariableResolver(VariableResolverType value);
-
-    /**
-	 * Returns the value of the '<em><b>View Declaration Language Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>View Declaration Language Factory</em>' containment reference.
-	 * @see #setViewDeclarationLanguageFactory(ViewDeclarationLanguageFactoryType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ViewDeclarationLanguageFactory()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='view-declaration-language-factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ViewDeclarationLanguageFactoryType getViewDeclarationLanguageFactory();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getViewDeclarationLanguageFactory <em>View Declaration Language Factory</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>View Declaration Language Factory</em>' containment reference.
-	 * @see #getViewDeclarationLanguageFactory()
-	 * @generated
-	 */
-	void setViewDeclarationLanguageFactory(ViewDeclarationLanguageFactoryType value);
-
-				/**
-	 * Returns the value of the '<em><b>View Handler</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 *       The "view-handler"
-	 *                 element contains the fully qualified class name     of
-	 *                 the concrete ViewHandler implementation class that will
-	 *                 be called     during the Restore View and Render
-	 *                 Response phases of the request     processing lifecycle.
-	 *                 The faces implementation must provide a     default
-	 *                 implementation of this class 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>View Handler</em>' containment reference.
-	 * @see #setViewHandler(ViewHandlerType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_ViewHandler()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='view-handler' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ViewHandlerType getViewHandler();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getViewHandler <em>View Handler</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>View Handler</em>' containment reference.
-	 * @see #getViewHandler()
-	 * @generated
-	 */
-	void setViewHandler(ViewHandlerType value);
-
-				/**
-	 * Returns the value of the '<em><b>Visit Context Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * <!-- begin-model-doc -->
-	 * 
-	 * <!-- end-model-doc -->
-	 * @return the value of the '<em>Visit Context Factory</em>' containment reference.
-	 * @see #setVisitContextFactory(VisitContextFactoryType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDocumentRoot_VisitContextFactory()
-	 * @model containment="true" upper="-2" transient="true" volatile="true" derived="true"
-	 *        extendedMetaData="kind='element' name='visit-context-factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	VisitContextFactoryType getVisitContextFactory();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getVisitContextFactory <em>Visit Context Factory</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Visit Context Factory</em>' containment reference.
-	 * @see #getVisitContextFactory()
-	 * @generated
-	 */
-	void setVisitContextFactory(VisitContextFactoryType value);
-
-} // DocumentRoot
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DynamicAttribute.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DynamicAttribute.java
deleted file mode 100644
index 4eac574..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DynamicAttribute.java
+++ /dev/null
@@ -1,93 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Dynamic Attribute</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DynamicAttribute#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DynamicAttribute#getValue <em>Value</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDynamicAttribute()
- * @model
- * @generated
- */
-public interface DynamicAttribute extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * 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.jst.jsf.facesconfig.emf.FacesConfigPackage#getDynamicAttribute_Name()
-	 * @model
-	 * @generated
-	 */
-    String getName();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DynamicAttribute#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);
-
-    /**
-	 * 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.jst.jsf.facesconfig.emf.FacesConfigPackage#getDynamicAttribute_Value()
-	 * @model
-	 * @generated
-	 */
-    String getValue();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DynamicAttribute#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);
-
-} // DynamicAttribute
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DynamicElement.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DynamicElement.java
deleted file mode 100644
index 3197969..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/DynamicElement.java
+++ /dev/null
@@ -1,128 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Dynamic Element</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DynamicElement#getChildNodes <em>Child Nodes</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DynamicElement#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DynamicElement#getAttributes <em>Attributes</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.DynamicElement#getTextContent <em>Text Content</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDynamicElement()
- * @model
- * @generated
- */
-public interface DynamicElement extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Child Nodes</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DynamicElement}.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Child Nodes</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>Child Nodes</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDynamicElement_ChildNodes()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DynamicElement" containment="true"
-	 * @generated
-	 */
-    EList getChildNodes();
-
-    /**
-	 * Returns the value of the '<em><b>Attributes</b></em>' reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DynamicAttribute}.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Attributes</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>Attributes</em>' reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDynamicElement_Attributes()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DynamicAttribute"
-	 * @generated
-	 */
-    EList getAttributes();
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getDynamicElement_TextContent()
-	 * @model
-	 * @generated
-	 */
-    String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DynamicElement#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-    void setTextContent(String value);
-
-    /**
-	 * 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.jst.jsf.facesconfig.emf.FacesConfigPackage#getDynamicElement_Name()
-	 * @model
-	 * @generated
-	 */
-    String getName();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.DynamicElement#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);
-
-} // DynamicElement
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ELResolverType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ELResolverType.java
deleted file mode 100644
index 793bfb0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ELResolverType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>EL Resolver Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ELResolverType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ELResolverType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getELResolverType()
- * @model extendedMetaData="name='el-resolver_._type' kind='simple'"
- * @generated
- */
-public interface ELResolverType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getELResolverType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-    String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ELResolverType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-    void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Id</em>' attribute isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getELResolverType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-    String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ELResolverType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-    void setId(String value);
-
-} // ELResolverType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ExceptionHandlerFactoryType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ExceptionHandlerFactoryType.java
deleted file mode 100644
index de6e30f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ExceptionHandlerFactoryType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Exception Handler Factory Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ExceptionHandlerFactoryType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ExceptionHandlerFactoryType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getExceptionHandlerFactoryType()
- * @model extendedMetaData="name='exception-handler-factory_._type' kind='simple'"
- * @generated
- */
-public interface ExceptionHandlerFactoryType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getExceptionHandlerFactoryType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ExceptionHandlerFactoryType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getExceptionHandlerFactoryType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ExceptionHandlerFactoryType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ExceptionHandlerFactoryType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ExtensionType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ExtensionType.java
deleted file mode 100644
index 613fa11..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ExtensionType.java
+++ /dev/null
@@ -1,112 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Extension Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ExtensionType#getChildNodes <em>Child Nodes</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ExtensionType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ExtensionType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getExtensionType()
- * @model abstract="true"
- * @generated
- */
-public interface ExtensionType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Child Nodes</b></em>' reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DynamicElement}.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Child Nodes</em>' reference list isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-	 * @return the value of the '<em>Child Nodes</em>' reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getExtensionType_ChildNodes()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DynamicElement"
-	 * @generated
-	 */
-    EList getChildNodes();
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getExtensionType_TextContent()
-	 * @model extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-    String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ExtensionType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-    void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Id</em>' attribute isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getExtensionType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-    String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ExtensionType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-    void setId(String value);
-
-} // ExtensionType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ExternalContextFactoryType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ExternalContextFactoryType.java
deleted file mode 100644
index 563f9b7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ExternalContextFactoryType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>External Context Factory Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ExternalContextFactoryType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ExternalContextFactoryType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getExternalContextFactoryType()
- * @model extendedMetaData="name='external-context-factory_._type' kind='simple'"
- * @generated
- */
-public interface ExternalContextFactoryType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getExternalContextFactoryType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ExternalContextFactoryType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getExternalContextFactoryType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ExternalContextFactoryType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ExternalContextFactoryType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacesConfigExtensionType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacesConfigExtensionType.java
deleted file mode 100644
index 2044448..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacesConfigExtensionType.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Extension Type</b></em>'.
- * <!-- end-user-doc -->
- *
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesConfigExtensionType()
- * @model extendedMetaData="name='faces-config-extension_._type'"
- * @generated
- */
-public interface FacesConfigExtensionType extends ExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-} // FacesConfigExtensionType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacesConfigFactory.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacesConfigFactory.java
deleted file mode 100644
index c01c1f3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacesConfigFactory.java
+++ /dev/null
@@ -1,1147 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-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.jst.jsf.facesconfig.emf.FacesConfigPackage
- * @generated
- */
-public interface FacesConfigFactory extends EFactory {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The singleton instance of the factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	FacesConfigFactory eINSTANCE = org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigFactoryImpl.init();
-
-    /**
-	 * Returns a new object of class '<em>Absolute Ordering Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Absolute Ordering Type</em>'.
-	 * @generated
-	 */
-	AbsoluteOrderingType createAbsoluteOrderingType();
-
-				/**
-	 * Returns a new object of class '<em>Action Listener Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Action Listener Type</em>'.
-	 * @generated
-	 */
-	ActionListenerType createActionListenerType();
-
-    /**
-	 * Returns a new object of class '<em>Application Factory Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Application Factory Type</em>'.
-	 * @generated
-	 */
-	ApplicationFactoryType createApplicationFactoryType();
-
-    /**
-	 * Returns a new object of class '<em>Application Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Application Type</em>'.
-	 * @generated
-	 */
-	ApplicationType createApplicationType();
-
-    /**
-	 * Returns a new object of class '<em>Attribute Class Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Attribute Class Type</em>'.
-	 * @generated
-	 */
-	AttributeClassType createAttributeClassType();
-
-    /**
-	 * Returns a new object of class '<em>Attribute Extension Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Attribute Extension Type</em>'.
-	 * @generated
-	 */
-	AttributeExtensionType createAttributeExtensionType();
-
-    /**
-	 * Returns a new object of class '<em>Attribute Name Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Attribute Name Type</em>'.
-	 * @generated
-	 */
-	AttributeNameType createAttributeNameType();
-
-    /**
-	 * Returns a new object of class '<em>Attribute Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Attribute Type</em>'.
-	 * @generated
-	 */
-	AttributeType createAttributeType();
-
-    /**
-	 * Returns a new object of class '<em>Behavior Class Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Behavior Class Type</em>'.
-	 * @generated
-	 */
-	BehaviorClassType createBehaviorClassType();
-
-				/**
-	 * Returns a new object of class '<em>Behavior Id Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Behavior Id Type</em>'.
-	 * @generated
-	 */
-	BehaviorIdType createBehaviorIdType();
-
-				/**
-	 * Returns a new object of class '<em>Behavior Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Behavior Type</em>'.
-	 * @generated
-	 */
-	BehaviorType createBehaviorType();
-
-				/**
-	 * Returns a new object of class '<em>Behavior Extension Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Behavior Extension Type</em>'.
-	 * @generated
-	 */
-	BehaviorExtensionType createBehaviorExtensionType();
-
-				/**
-	 * Returns a new object of class '<em>Client Behavior Renderer Class Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Client Behavior Renderer Class Type</em>'.
-	 * @generated
-	 */
-	ClientBehaviorRendererClassType createClientBehaviorRendererClassType();
-
-				/**
-	 * Returns a new object of class '<em>Client Behavior Renderer Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Client Behavior Renderer Type</em>'.
-	 * @generated
-	 */
-	ClientBehaviorRendererType createClientBehaviorRendererType();
-
-				/**
-	 * Returns a new object of class '<em>Client Behavior Renderer Type Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Client Behavior Renderer Type Type</em>'.
-	 * @generated
-	 */
-	ClientBehaviorRendererTypeType createClientBehaviorRendererTypeType();
-
-				/**
-	 * Returns a new object of class '<em>Component Class Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Component Class Type</em>'.
-	 * @generated
-	 */
-	ComponentClassType createComponentClassType();
-
-    /**
-	 * Returns a new object of class '<em>Component Extension Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Component Extension Type</em>'.
-	 * @generated
-	 */
-	ComponentExtensionType createComponentExtensionType();
-
-    /**
-	 * Returns a new object of class '<em>Component Family Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Component Family Type</em>'.
-	 * @generated
-	 */
-	ComponentFamilyType createComponentFamilyType();
-
-    /**
-	 * Returns a new object of class '<em>Component Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Component Type</em>'.
-	 * @generated
-	 */
-	ComponentType createComponentType();
-
-    /**
-	 * Returns a new object of class '<em>Component Type Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Component Type Type</em>'.
-	 * @generated
-	 */
-	ComponentTypeType createComponentTypeType();
-
-    /**
-	 * Returns a new object of class '<em>Converter Class Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Converter Class Type</em>'.
-	 * @generated
-	 */
-	ConverterClassType createConverterClassType();
-
-    /**
-	 * Returns a new object of class '<em>Converter For Class Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Converter For Class Type</em>'.
-	 * @generated
-	 */
-	ConverterForClassType createConverterForClassType();
-
-    /**
-	 * Returns a new object of class '<em>Converter Id Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Converter Id Type</em>'.
-	 * @generated
-	 */
-	ConverterIdType createConverterIdType();
-
-    /**
-	 * Returns a new object of class '<em>Converter Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Converter Type</em>'.
-	 * @generated
-	 */
-	ConverterType createConverterType();
-
-    /**
-	 * Returns a new object of class '<em>Default Locale Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Default Locale Type</em>'.
-	 * @generated
-	 */
-	DefaultLocaleType createDefaultLocaleType();
-
-    /**
-	 * Returns a new object of class '<em>Default Render Kit Id Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Default Render Kit Id Type</em>'.
-	 * @generated
-	 */
-	DefaultRenderKitIdType createDefaultRenderKitIdType();
-
-    /**
-	 * Returns a new object of class '<em>Default Validators Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Default Validators Type</em>'.
-	 * @generated
-	 */
-	DefaultValidatorsType createDefaultValidatorsType();
-
-				/**
-	 * Returns a new object of class '<em>Default Value Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Default Value Type</em>'.
-	 * @generated
-	 */
-	DefaultValueType createDefaultValueType();
-
-    /**
-	 * Returns a new object of class '<em>Description Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Description Type</em>'.
-	 * @generated
-	 */
-	DescriptionType createDescriptionType();
-
-    /**
-	 * Returns a new object of class '<em>Display Name Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Display Name Type</em>'.
-	 * @generated
-	 */
-	DisplayNameType createDisplayNameType();
-
-    /**
-	 * Returns a new object of class '<em>Document Root</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Document Root</em>'.
-	 * @generated
-	 */
-	DocumentRoot createDocumentRoot();
-
-    /**
-	 * Returns a new object of class '<em>Dynamic Attribute</em>'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Dynamic Attribute</em>'.
-	 * @generated
-	 */
-    DynamicAttribute createDynamicAttribute();
-
-    /**
-	 * Returns a new object of class '<em>Dynamic Element</em>'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Dynamic Element</em>'.
-	 * @generated
-	 */
-    DynamicElement createDynamicElement();
-
-    /**
-	 * Returns a new object of class '<em>EL Resolver Type</em>'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return a new object of class '<em>EL Resolver Type</em>'.
-	 * @generated
-	 */
-    ELResolverType createELResolverType();
-
-    /**
-	 * Returns a new object of class '<em>Exception Handler Factory Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Exception Handler Factory Type</em>'.
-	 * @generated
-	 */
-	ExceptionHandlerFactoryType createExceptionHandlerFactoryType();
-
-				/**
-	 * Returns a new object of class '<em>External Context Factory Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>External Context Factory Type</em>'.
-	 * @generated
-	 */
-	ExternalContextFactoryType createExternalContextFactoryType();
-
-				/**
-	 * Returns a new object of class '<em>Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Type</em>'.
-	 * @generated
-	 */
-	FacesConfigType createFacesConfigType();
-
-    /**
-	 * Returns a new object of class '<em>Faces Context Factory Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Faces Context Factory Type</em>'.
-	 * @generated
-	 */
-	FacesContextFactoryType createFacesContextFactoryType();
-
-    /**
-	 * Returns a new object of class '<em>Facet Extension Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Facet Extension Type</em>'.
-	 * @generated
-	 */
-	FacetExtensionType createFacetExtensionType();
-
-    /**
-	 * Returns a new object of class '<em>Facet Name Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Facet Name Type</em>'.
-	 * @generated
-	 */
-	FacetNameType createFacetNameType();
-
-    /**
-	 * Returns a new object of class '<em>Facet Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Facet Type</em>'.
-	 * @generated
-	 */
-	FacetType createFacetType();
-
-    /**
-	 * Returns a new object of class '<em>Factory Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Factory Type</em>'.
-	 * @generated
-	 */
-	FactoryType createFactoryType();
-
-    /**
-	 * Returns a new object of class '<em>From Action Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>From Action Type</em>'.
-	 * @generated
-	 */
-	FromActionType createFromActionType();
-
-    /**
-	 * Returns a new object of class '<em>From Outcome Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>From Outcome Type</em>'.
-	 * @generated
-	 */
-	FromOutcomeType createFromOutcomeType();
-
-    /**
-	 * Returns a new object of class '<em>From View Id Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>From View Id Type</em>'.
-	 * @generated
-	 */
-	FromViewIdType createFromViewIdType();
-
-    /**
-	 * Returns a new object of class '<em>Icon Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Icon Type</em>'.
-	 * @generated
-	 */
-	IconType createIconType();
-
-    /**
-	 * Returns a new object of class '<em>If Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>If Type</em>'.
-	 * @generated
-	 */
-	IfType createIfType();
-
-				/**
-	 * Returns a new object of class '<em>Key Class Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Key Class Type</em>'.
-	 * @generated
-	 */
-	KeyClassType createKeyClassType();
-
-    /**
-	 * Returns a new object of class '<em>Key Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Key Type</em>'.
-	 * @generated
-	 */
-	KeyType createKeyType();
-
-    /**
-	 * Returns a new object of class '<em>Large Icon Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Large Icon Type</em>'.
-	 * @generated
-	 */
-	LargeIconType createLargeIconType();
-
-    /**
-	 * Returns a new object of class '<em>Lifecycle Factory Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Lifecycle Factory Type</em>'.
-	 * @generated
-	 */
-	LifecycleFactoryType createLifecycleFactoryType();
-
-    /**
-	 * Returns a new object of class '<em>Lifecycle Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Lifecycle Type</em>'.
-	 * @generated
-	 */
-	LifecycleType createLifecycleType();
-
-    /**
-	 * Returns a new object of class '<em>List Entries Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>List Entries Type</em>'.
-	 * @generated
-	 */
-	ListEntriesType createListEntriesType();
-
-    /**
-	 * Returns a new object of class '<em>Locale Config Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Locale Config Type</em>'.
-	 * @generated
-	 */
-	LocaleConfigType createLocaleConfigType();
-
-    /**
-	 * Returns a new object of class '<em>Managed Bean Class Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Managed Bean Class Type</em>'.
-	 * @generated
-	 */
-	ManagedBeanClassType createManagedBeanClassType();
-
-    /**
-	 * Returns a new object of class '<em>Managed Bean Name Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Managed Bean Name Type</em>'.
-	 * @generated
-	 */
-	ManagedBeanNameType createManagedBeanNameType();
-
-    /**
-	 * Returns a new object of class '<em>Managed Bean Scope Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Managed Bean Scope Type</em>'.
-	 * @generated
-	 */
-	ManagedBeanScopeType createManagedBeanScopeType();
-
-    /**
-	 * Returns a new object of class '<em>Managed Bean Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Managed Bean Type</em>'.
-	 * @generated
-	 */
-	ManagedBeanType createManagedBeanType();
-
-    /**
-	 * Returns a new object of class '<em>Managed Property Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Managed Property Type</em>'.
-	 * @generated
-	 */
-	ManagedPropertyType createManagedPropertyType();
-
-    /**
-	 * Returns a new object of class '<em>Map Entries Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Map Entries Type</em>'.
-	 * @generated
-	 */
-	MapEntriesType createMapEntriesType();
-
-    /**
-	 * Returns a new object of class '<em>Map Entry Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Map Entry Type</em>'.
-	 * @generated
-	 */
-	MapEntryType createMapEntryType();
-
-    /**
-	 * Returns a new object of class '<em>Message Bundle Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Message Bundle Type</em>'.
-	 * @generated
-	 */
-	MessageBundleType createMessageBundleType();
-
-    /**
-	 * Returns a new object of class '<em>Name Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Name Type</em>'.
-	 * @generated
-	 */
-	NameType createNameType();
-
-				/**
-	 * Returns a new object of class '<em>Navigation Case Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Navigation Case Type</em>'.
-	 * @generated
-	 */
-	NavigationCaseType createNavigationCaseType();
-
-    /**
-	 * Returns a new object of class '<em>Navigation Handler Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Navigation Handler Type</em>'.
-	 * @generated
-	 */
-	NavigationHandlerType createNavigationHandlerType();
-
-    /**
-	 * Returns a new object of class '<em>Navigation Rule Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Navigation Rule Type</em>'.
-	 * @generated
-	 */
-	NavigationRuleType createNavigationRuleType();
-
-    /**
-	 * Returns a new object of class '<em>Null Value Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Null Value Type</em>'.
-	 * @generated
-	 */
-	NullValueType createNullValueType();
-
-    /**
-	 * Returns a new object of class '<em>Ordering Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Ordering Type</em>'.
-	 * @generated
-	 */
-	OrderingType createOrderingType();
-
-				/**
-	 * Returns a new object of class '<em>Ordering Ordering Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Ordering Ordering Type</em>'.
-	 * @generated
-	 */
-	OrderingOrderingType createOrderingOrderingType();
-
-				/**
-	 * Returns a new object of class '<em>Ordering Others Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Ordering Others Type</em>'.
-	 * @generated
-	 */
-	OrderingOthersType createOrderingOthersType();
-
-				/**
-	 * Returns a new object of class '<em>Partial View Context Factory Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Partial View Context Factory Type</em>'.
-	 * @generated
-	 */
-	PartialViewContextFactoryType createPartialViewContextFactoryType();
-
-				/**
-	 * Returns a new object of class '<em>Phase Listener Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Phase Listener Type</em>'.
-	 * @generated
-	 */
-	PhaseListenerType createPhaseListenerType();
-
-    /**
-	 * Returns a new object of class '<em>Property Class Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Property Class Type</em>'.
-	 * @generated
-	 */
-	PropertyClassType createPropertyClassType();
-
-    /**
-	 * Returns a new object of class '<em>Property Extension Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Property Extension Type</em>'.
-	 * @generated
-	 */
-	PropertyExtensionType createPropertyExtensionType();
-
-    /**
-	 * Returns a new object of class '<em>Property Name Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Property Name Type</em>'.
-	 * @generated
-	 */
-	PropertyNameType createPropertyNameType();
-
-    /**
-	 * Returns a new object of class '<em>Property Resolver Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Property Resolver Type</em>'.
-	 * @generated
-	 */
-	PropertyResolverType createPropertyResolverType();
-
-    /**
-	 * Returns a new object of class '<em>Property Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Property Type</em>'.
-	 * @generated
-	 */
-	PropertyType createPropertyType();
-
-    /**
-	 * Returns a new object of class '<em>Redirect Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Redirect Type</em>'.
-	 * @generated
-	 */
-	RedirectType createRedirectType();
-
-    /**
-	 * Returns a new object of class '<em>Redirect View Param Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Redirect View Param Type</em>'.
-	 * @generated
-	 */
-	RedirectViewParamType createRedirectViewParamType();
-
-				/**
-	 * Returns a new object of class '<em>Referenced Bean Class Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Referenced Bean Class Type</em>'.
-	 * @generated
-	 */
-	ReferencedBeanClassType createReferencedBeanClassType();
-
-    /**
-	 * Returns a new object of class '<em>Referenced Bean Name Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Referenced Bean Name Type</em>'.
-	 * @generated
-	 */
-	ReferencedBeanNameType createReferencedBeanNameType();
-
-    /**
-	 * Returns a new object of class '<em>Referenced Bean Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Referenced Bean Type</em>'.
-	 * @generated
-	 */
-	ReferencedBeanType createReferencedBeanType();
-
-    /**
-	 * Returns a new object of class '<em>Renderer Class Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Renderer Class Type</em>'.
-	 * @generated
-	 */
-	RendererClassType createRendererClassType();
-
-    /**
-	 * Returns a new object of class '<em>Renderer Extension Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Renderer Extension Type</em>'.
-	 * @generated
-	 */
-	RendererExtensionType createRendererExtensionType();
-
-    /**
-	 * Returns a new object of class '<em>Renderer Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Renderer Type</em>'.
-	 * @generated
-	 */
-	RendererType createRendererType();
-
-    /**
-	 * Returns a new object of class '<em>Renderer Type Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Renderer Type Type</em>'.
-	 * @generated
-	 */
-	RendererTypeType createRendererTypeType();
-
-    /**
-	 * Returns a new object of class '<em>Render Kit Class Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Render Kit Class Type</em>'.
-	 * @generated
-	 */
-	RenderKitClassType createRenderKitClassType();
-
-    /**
-	 * Returns a new object of class '<em>Render Kit Factory Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Render Kit Factory Type</em>'.
-	 * @generated
-	 */
-	RenderKitFactoryType createRenderKitFactoryType();
-
-    /**
-	 * Returns a new object of class '<em>Render Kit Id Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Render Kit Id Type</em>'.
-	 * @generated
-	 */
-	RenderKitIdType createRenderKitIdType();
-
-    /**
-	 * Returns a new object of class '<em>Render Kit Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Render Kit Type</em>'.
-	 * @generated
-	 */
-	RenderKitType createRenderKitType();
-
-    /**
-	 * Returns a new object of class '<em>Small Icon Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Small Icon Type</em>'.
-	 * @generated
-	 */
-	SmallIconType createSmallIconType();
-
-    /**
-	 * Returns a new object of class '<em>Source Class Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Source Class Type</em>'.
-	 * @generated
-	 */
-	SourceClassType createSourceClassType();
-
-				/**
-	 * Returns a new object of class '<em>State Manager Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>State Manager Type</em>'.
-	 * @generated
-	 */
-	StateManagerType createStateManagerType();
-
-    /**
-	 * Returns a new object of class '<em>Suggested Value Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Suggested Value Type</em>'.
-	 * @generated
-	 */
-	SuggestedValueType createSuggestedValueType();
-
-    /**
-	 * Returns a new object of class '<em>Supported Locale Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Supported Locale Type</em>'.
-	 * @generated
-	 */
-	SupportedLocaleType createSupportedLocaleType();
-
-    /**
-	 * Returns a new object of class '<em>System Event Class Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>System Event Class Type</em>'.
-	 * @generated
-	 */
-	SystemEventClassType createSystemEventClassType();
-
-				/**
-	 * Returns a new object of class '<em>System Event Listener Class Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>System Event Listener Class Type</em>'.
-	 * @generated
-	 */
-	SystemEventListenerClassType createSystemEventListenerClassType();
-
-				/**
-	 * Returns a new object of class '<em>System Event Listener Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>System Event Listener Type</em>'.
-	 * @generated
-	 */
-	SystemEventListenerType createSystemEventListenerType();
-
-				/**
-	 * Returns a new object of class '<em>Tag Handler Delegate Factory Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Tag Handler Delegate Factory Type</em>'.
-	 * @generated
-	 */
-	TagHandlerDelegateFactoryType createTagHandlerDelegateFactoryType();
-
-				/**
-	 * Returns a new object of class '<em>To View Id Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>To View Id Type</em>'.
-	 * @generated
-	 */
-	ToViewIdType createToViewIdType();
-
-    /**
-	 * Returns a new object of class '<em>Validator Class Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Validator Class Type</em>'.
-	 * @generated
-	 */
-	ValidatorClassType createValidatorClassType();
-
-    /**
-	 * Returns a new object of class '<em>Validator Id Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Validator Id Type</em>'.
-	 * @generated
-	 */
-	ValidatorIdType createValidatorIdType();
-
-    /**
-	 * Returns a new object of class '<em>Validator Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Validator Type</em>'.
-	 * @generated
-	 */
-	ValidatorType createValidatorType();
-
-    /**
-	 * Returns a new object of class '<em>Value Class Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Value Class Type</em>'.
-	 * @generated
-	 */
-	ValueClassType createValueClassType();
-
-    /**
-	 * Returns a new object of class '<em>Value Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Value Type</em>'.
-	 * @generated
-	 */
-	ValueType createValueType();
-
-    /**
-	 * Returns a new object of class '<em>Variable Resolver Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Variable Resolver Type</em>'.
-	 * @generated
-	 */
-	VariableResolverType createVariableResolverType();
-
-    /**
-	 * Returns a new object of class '<em>View Handler Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>View Handler Type</em>'.
-	 * @generated
-	 */
-	ViewHandlerType createViewHandlerType();
-
-    /**
-	 * Returns a new object of class '<em>Application Extension Type</em>'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Application Extension Type</em>'.
-	 * @generated
-	 */
-    ApplicationExtensionType createApplicationExtensionType();
-
-    /**
-	 * Returns a new object of class '<em>Resource Bundle Type</em>'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Resource Bundle Type</em>'.
-	 * @generated
-	 */
-    ResourceBundleType createResourceBundleType();
-
-    /**
-	 * Returns a new object of class '<em>Base Name Type</em>'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Base Name Type</em>'.
-	 * @generated
-	 */
-    BaseNameType createBaseNameType();
-
-    /**
-	 * Returns a new object of class '<em>Var Type</em>'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Var Type</em>'.
-	 * @generated
-	 */
-    VarType createVarType();
-
-    /**
-	 * Returns a new object of class '<em>View Declaration Language Factory Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>View Declaration Language Factory Type</em>'.
-	 * @generated
-	 */
-	ViewDeclarationLanguageFactoryType createViewDeclarationLanguageFactoryType();
-
-				/**
-	 * Returns a new object of class '<em>Visit Context Factory Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Visit Context Factory Type</em>'.
-	 * @generated
-	 */
-	VisitContextFactoryType createVisitContextFactoryType();
-
-				/**
-	 * Returns a new object of class '<em>Render Kit Extension Type</em>'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Render Kit Extension Type</em>'.
-	 * @generated
-	 */
-    RenderKitExtensionType createRenderKitExtensionType();
-
-    /**
-	 * Returns a new object of class '<em>Resource Handler Type</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Resource Handler Type</em>'.
-	 * @generated
-	 */
-	ResourceHandlerType createResourceHandlerType();
-
-				/**
-	 * Returns a new object of class '<em>Navigation Rule Extension Type</em>'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Navigation Rule Extension Type</em>'.
-	 * @generated
-	 */
-    NavigationRuleExtensionType createNavigationRuleExtensionType();
-
-    /**
-	 * Returns a new object of class '<em>Validator Extension Type</em>'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Validator Extension Type</em>'.
-	 * @generated
-	 */
-    ValidatorExtensionType createValidatorExtensionType();
-
-    /**
-	 * Returns a new object of class '<em>Extension Type</em>'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Extension Type</em>'.
-	 * @generated
-	 */
-    FacesConfigExtensionType createFacesConfigExtensionType();
-
-    /**
-	 * Returns a new object of class '<em>Factory Extension Type</em>'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Factory Extension Type</em>'.
-	 * @generated
-	 */
-    FactoryExtensionType createFactoryExtensionType();
-
-    /**
-	 * Returns a new object of class '<em>Lifecycle Extension Type</em>'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Lifecycle Extension Type</em>'.
-	 * @generated
-	 */
-    LifecycleExtensionType createLifecycleExtensionType();
-
-    /**
-	 * Returns a new object of class '<em>Managed Bean Extension Type</em>'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Managed Bean Extension Type</em>'.
-	 * @generated
-	 */
-    ManagedBeanExtensionType createManagedBeanExtensionType();
-
-    /**
-	 * Returns a new object of class '<em>Converter Extension Type</em>'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Converter Extension Type</em>'.
-	 * @generated
-	 */
-    ConverterExtensionType createConverterExtensionType();
-
-    /**
-	 * Returns the package supported by this factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the package supported by this factory.
-	 * @generated
-	 */
-	FacesConfigPackage getFacesConfigPackage();
-
-} //FacesConfigFactory
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacesConfigPackage.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacesConfigPackage.java
deleted file mode 100644
index c2a356e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacesConfigPackage.java
+++ /dev/null
@@ -1,18749 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EAttribute;
-import org.eclipse.emf.ecore.EClass;
-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 enum,</li>
- *   <li>and each data type</li>
- * </ul>
- * <!-- end-user-doc -->
- * <!-- begin-model-doc -->
- * 
- *    See http://www.w3.org/XML/1998/namespace.html and
- *    http://www.w3.org/TR/REC-xml for information about this namespace.
- * 
- *     This schema document describes the XML namespace, in a form
- *     suitable for import by other schema documents.  
- * 
- *     Note that local names in this namespace are intended to be defined
- *     only by the World Wide Web Consortium or its subgroups.  The
- *     following names are currently defined in this namespace and should
- *     not be used with conflicting semantics by any Working Group,
- *     specification, or document instance:
- * 
- *     base (as an attribute name): denotes an attribute whose value
- *          provides a URI to be used as the base for interpreting any
- *          relative URIs in the scope of the element on which it
- *          appears; its value is inherited.  This name is reserved
- *          by virtue of its definition in the XML Base specification.
- * 
- *     id   (as an attribute name): denotes an attribute whose value
- *          should be interpreted as if declared to be of type ID.
- *          The xml:id specification is not yet a W3C Recommendation,
- *          but this attribute is included here to facilitate experimentation
- *          with the mechanisms it proposes.  Note that it is _not_ included
- *          in the specialAttrs attribute group.
- * 
- *     lang (as an attribute name): denotes an attribute whose value
- *          is a language code for the natural language of the content of
- *          any element; its value is inherited.  This name is reserved
- *          by virtue of its definition in the XML specification.
- *   
- *     space (as an attribute name): denotes an attribute whose
- *          value is a keyword indicating what whitespace processing
- *          discipline is intended for the content of the element; its
- *          value is inherited.  This name is reserved by virtue of its
- *          definition in the XML specification.
- * 
- *     Father (in any context at all): denotes Jon Bosak, the chair of 
- *          the original XML Working Group.  This name is reserved by 
- *          the following decision of the W3C XML Plenary and 
- *          XML Coordination groups:
- * 
- *              In appreciation for his vision, leadership and dedication
- *              the W3C XML Plenary on this 10th day of February, 2000
- *              reserves for Jon Bosak in perpetuity the XML name
- *              xml:Father
- *   
- * This schema defines attributes and an attribute group
- *         suitable for use by
- *         schemas wishing to allow xml:base, xml:lang, xml:space or xml:id
- *         attributes on elements they define.
- * 
- *         To enable this, such a schema must import this schema
- *         for the XML namespace, e.g. as follows:
- *         &lt;schema . . .&gt;
- *          . . .
- *          &lt;import namespace="http://www.w3.org/XML/1998/namespace"
- *                     schemaLocation="http://www.w3.org/2001/xml.xsd"/&gt;
- * 
- *         Subsequently, qualified reference to any of the attributes
- *         or the group defined below will have the desired effect, e.g.
- * 
- *         &lt;type . . .&gt;
- *          . . .
- *          &lt;attributeGroup ref="xml:specialAttrs"/&gt;
- *  
- *          will define a type which will schema-validate an instance
- *          element with any of those attributes
- * In keeping with the XML Schema WG's standard versioning
- *    policy, this schema document will persist at
- *    http://www.w3.org/2005/08/xml.xsd.
- *    At the date of issue it can also be found at
- *    http://www.w3.org/2001/xml.xsd.
- *    The schema document at that URI may however change in the future,
- *    in order to remain compatible with the latest version of XML Schema
- *    itself, or with the XML namespace itself.  In other words, if the XML
- *    Schema or XML namespaces change, the version of this document at
- *    http://www.w3.org/2001/xml.xsd will change
- *    accordingly; the version at
- *    http://www.w3.org/2005/08/xml.xsd will not change.
- *   
- * <!-- end-model-doc -->
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory
- * @model kind="package"
- *        extendedMetaData="qualified='false'"
- * @generated
- */
-@SuppressWarnings("hiding")
-public interface FacesConfigPackage extends EPackage {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The package name.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String eNAME = "facesconfig"; //$NON-NLS-1$
-
-    /**
-	 * The package namespace URI.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String eNS_URI = "http://www.eclipse.org/webtools/jsf/schema/facesconfig.xsd"; //$NON-NLS-1$
-
-    /**
-	 * The package namespace name.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String eNS_PREFIX = "facesconfig"; //$NON-NLS-1$
-
-    /**
-	 * The singleton instance of the package.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	FacesConfigPackage eINSTANCE = org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl.init();
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AbsoluteOrderingTypeImpl <em>Absolute Ordering Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.AbsoluteOrderingTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getAbsoluteOrderingType()
-	 * @generated
-	 */
-	int ABSOLUTE_ORDERING_TYPE = 0;
-
-				/**
-	 * The feature id for the '<em><b>Name</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ABSOLUTE_ORDERING_TYPE__NAME = 0;
-
-				/**
-	 * The feature id for the '<em><b>Others</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ABSOLUTE_ORDERING_TYPE__OTHERS = 1;
-
-				/**
-	 * The number of structural features of the '<em>Absolute Ordering Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ABSOLUTE_ORDERING_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ActionListenerTypeImpl <em>Action Listener Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ActionListenerTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getActionListenerType()
-	 * @generated
-	 */
-	int ACTION_LISTENER_TYPE = 1;
-
-    /**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ACTION_LISTENER_TYPE__TEXT_CONTENT = 0;
-
-    /**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ACTION_LISTENER_TYPE__ID = 1;
-
-    /**
-	 * The number of structural features of the '<em>Action Listener Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ACTION_LISTENER_TYPE_FEATURE_COUNT = 2;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationFactoryTypeImpl <em>Application Factory Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationFactoryTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getApplicationFactoryType()
-	 * @generated
-	 */
-	int APPLICATION_FACTORY_TYPE = 2;
-
-    /**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int APPLICATION_FACTORY_TYPE__TEXT_CONTENT = 0;
-
-    /**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int APPLICATION_FACTORY_TYPE__ID = 1;
-
-    /**
-	 * The number of structural features of the '<em>Application Factory Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int APPLICATION_FACTORY_TYPE_FEATURE_COUNT = 2;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl <em>Application Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getApplicationType()
-	 * @generated
-	 */
-	int APPLICATION_TYPE = 3;
-
-    /**
-	 * The feature id for the '<em><b>Action Listener</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int APPLICATION_TYPE__ACTION_LISTENER = 0;
-
-    /**
-	 * The feature id for the '<em><b>Default Render Kit Id</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int APPLICATION_TYPE__DEFAULT_RENDER_KIT_ID = 1;
-
-    /**
-	 * The feature id for the '<em><b>Message Bundle</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int APPLICATION_TYPE__MESSAGE_BUNDLE = 2;
-
-    /**
-	 * The feature id for the '<em><b>Navigation Handler</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int APPLICATION_TYPE__NAVIGATION_HANDLER = 3;
-
-    /**
-	 * The feature id for the '<em><b>View Handler</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int APPLICATION_TYPE__VIEW_HANDLER = 4;
-
-    /**
-	 * The feature id for the '<em><b>State Manager</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int APPLICATION_TYPE__STATE_MANAGER = 5;
-
-    /**
-	 * The feature id for the '<em><b>EL Resolver</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int APPLICATION_TYPE__EL_RESOLVER = 6;
-
-				/**
-	 * The feature id for the '<em><b>Property Resolver</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int APPLICATION_TYPE__PROPERTY_RESOLVER = 7;
-
-				/**
-	 * The feature id for the '<em><b>Variable Resolver</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int APPLICATION_TYPE__VARIABLE_RESOLVER = 8;
-
-				/**
-	 * The feature id for the '<em><b>Resource Handler</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int APPLICATION_TYPE__RESOURCE_HANDLER = 9;
-
-				/**
-	 * The feature id for the '<em><b>System Event Listener</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int APPLICATION_TYPE__SYSTEM_EVENT_LISTENER = 10;
-
-				/**
-	 * The feature id for the '<em><b>Locale Config</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int APPLICATION_TYPE__LOCALE_CONFIG = 11;
-
-    /**
-	 * The feature id for the '<em><b>Resource Bundle</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int APPLICATION_TYPE__RESOURCE_BUNDLE = 12;
-
-    /**
-	 * The feature id for the '<em><b>Application Extension</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int APPLICATION_TYPE__APPLICATION_EXTENSION = 13;
-
-    /**
-	 * The feature id for the '<em><b>Default Validators</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int APPLICATION_TYPE__DEFAULT_VALIDATORS = 14;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int APPLICATION_TYPE__ID = 15;
-
-				/**
-	 * The number of structural features of the '<em>Application Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int APPLICATION_TYPE_FEATURE_COUNT = 16;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeClassTypeImpl <em>Attribute Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getAttributeClassType()
-	 * @generated
-	 */
-	int ATTRIBUTE_CLASS_TYPE = 5;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeExtensionTypeImpl <em>Attribute Extension Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeExtensionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getAttributeExtensionType()
-	 * @generated
-	 */
-	int ATTRIBUTE_EXTENSION_TYPE = 6;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeNameTypeImpl <em>Attribute Name Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeNameTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getAttributeNameType()
-	 * @generated
-	 */
-	int ATTRIBUTE_NAME_TYPE = 7;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeTypeImpl <em>Attribute Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getAttributeType()
-	 * @generated
-	 */
-	int ATTRIBUTE_TYPE = 8;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentClassTypeImpl <em>Component Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getComponentClassType()
-	 * @generated
-	 */
-	int COMPONENT_CLASS_TYPE = 16;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ExtensionTypeImpl <em>Extension Type</em>}' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ExtensionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getExtensionType()
-	 * @generated
-	 */
-    int EXTENSION_TYPE = 37;
-
-    /**
-	 * The feature id for the '<em><b>Child Nodes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int EXTENSION_TYPE__CHILD_NODES = 0;
-
-    /**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int EXTENSION_TYPE__TEXT_CONTENT = 1;
-
-    /**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int EXTENSION_TYPE__ID = 2;
-
-    /**
-	 * The number of structural features of the '<em>Extension Type</em>' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int EXTENSION_TYPE_FEATURE_COUNT = 3;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorClassTypeImpl <em>Behavior Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getBehaviorClassType()
-	 * @generated
-	 */
-	int BEHAVIOR_CLASS_TYPE = 9;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorIdTypeImpl <em>Behavior Id Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorIdTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getBehaviorIdType()
-	 * @generated
-	 */
-	int BEHAVIOR_ID_TYPE = 10;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorTypeImpl <em>Behavior Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getBehaviorType()
-	 * @generated
-	 */
-	int BEHAVIOR_TYPE = 11;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorExtensionTypeImpl <em>Behavior Extension Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorExtensionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getBehaviorExtensionType()
-	 * @generated
-	 */
-	int BEHAVIOR_EXTENSION_TYPE = 12;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ClientBehaviorRendererClassTypeImpl <em>Client Behavior Renderer Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ClientBehaviorRendererClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getClientBehaviorRendererClassType()
-	 * @generated
-	 */
-	int CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE = 13;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ClientBehaviorRendererTypeImpl <em>Client Behavior Renderer Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ClientBehaviorRendererTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getClientBehaviorRendererType()
-	 * @generated
-	 */
-	int CLIENT_BEHAVIOR_RENDERER_TYPE = 14;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ClientBehaviorRendererTypeTypeImpl <em>Client Behavior Renderer Type Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ClientBehaviorRendererTypeTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getClientBehaviorRendererTypeType()
-	 * @generated
-	 */
-	int CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE = 15;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentExtensionTypeImpl <em>Component Extension Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentExtensionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getComponentExtensionType()
-	 * @generated
-	 */
-	int COMPONENT_EXTENSION_TYPE = 17;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentFamilyTypeImpl <em>Component Family Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentFamilyTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getComponentFamilyType()
-	 * @generated
-	 */
-	int COMPONENT_FAMILY_TYPE = 18;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeImpl <em>Component Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getComponentType()
-	 * @generated
-	 */
-	int COMPONENT_TYPE = 19;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeTypeImpl <em>Component Type Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getComponentTypeType()
-	 * @generated
-	 */
-	int COMPONENT_TYPE_TYPE = 20;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterClassTypeImpl <em>Converter Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getConverterClassType()
-	 * @generated
-	 */
-	int CONVERTER_CLASS_TYPE = 21;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterForClassTypeImpl <em>Converter For Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterForClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getConverterForClassType()
-	 * @generated
-	 */
-	int CONVERTER_FOR_CLASS_TYPE = 22;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterIdTypeImpl <em>Converter Id Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterIdTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getConverterIdType()
-	 * @generated
-	 */
-	int CONVERTER_ID_TYPE = 23;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterTypeImpl <em>Converter Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getConverterType()
-	 * @generated
-	 */
-	int CONVERTER_TYPE = 24;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultLocaleTypeImpl <em>Default Locale Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultLocaleTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDefaultLocaleType()
-	 * @generated
-	 */
-	int DEFAULT_LOCALE_TYPE = 26;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultRenderKitIdTypeImpl <em>Default Render Kit Id Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultRenderKitIdTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDefaultRenderKitIdType()
-	 * @generated
-	 */
-	int DEFAULT_RENDER_KIT_ID_TYPE = 27;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultValidatorsTypeImpl <em>Default Validators Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultValidatorsTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDefaultValidatorsType()
-	 * @generated
-	 */
-	int DEFAULT_VALIDATORS_TYPE = 28;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultValueTypeImpl <em>Default Value Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultValueTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDefaultValueType()
-	 * @generated
-	 */
-	int DEFAULT_VALUE_TYPE = 29;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DescriptionTypeImpl <em>Description Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DescriptionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDescriptionType()
-	 * @generated
-	 */
-	int DESCRIPTION_TYPE = 30;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DisplayNameTypeImpl <em>Display Name Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DisplayNameTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDisplayNameType()
-	 * @generated
-	 */
-	int DISPLAY_NAME_TYPE = 31;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl <em>Document Root</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDocumentRoot()
-	 * @generated
-	 */
-	int DOCUMENT_ROOT = 32;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DynamicAttributeImpl <em>Dynamic Attribute</em>}' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DynamicAttributeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDynamicAttribute()
-	 * @generated
-	 */
-    int DYNAMIC_ATTRIBUTE = 33;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DynamicElementImpl <em>Dynamic Element</em>}' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DynamicElementImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDynamicElement()
-	 * @generated
-	 */
-    int DYNAMIC_ELEMENT = 34;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ELResolverTypeImpl <em>EL Resolver Type</em>}' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ELResolverTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getELResolverType()
-	 * @generated
-	 */
-    int EL_RESOLVER_TYPE = 35;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl <em>Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFacesConfigType()
-	 * @generated
-	 */
-	int FACES_CONFIG_TYPE = 39;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesContextFactoryTypeImpl <em>Faces Context Factory Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesContextFactoryTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFacesContextFactoryType()
-	 * @generated
-	 */
-	int FACES_CONTEXT_FACTORY_TYPE = 41;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacetExtensionTypeImpl <em>Facet Extension Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacetExtensionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFacetExtensionType()
-	 * @generated
-	 */
-	int FACET_EXTENSION_TYPE = 42;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacetNameTypeImpl <em>Facet Name Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacetNameTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFacetNameType()
-	 * @generated
-	 */
-	int FACET_NAME_TYPE = 43;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacetTypeImpl <em>Facet Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacetTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFacetType()
-	 * @generated
-	 */
-	int FACET_TYPE = 44;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryTypeImpl <em>Factory Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFactoryType()
-	 * @generated
-	 */
-	int FACTORY_TYPE = 45;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FromActionTypeImpl <em>From Action Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FromActionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFromActionType()
-	 * @generated
-	 */
-	int FROM_ACTION_TYPE = 47;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FromOutcomeTypeImpl <em>From Outcome Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FromOutcomeTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFromOutcomeType()
-	 * @generated
-	 */
-	int FROM_OUTCOME_TYPE = 48;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FromViewIdTypeImpl <em>From View Id Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FromViewIdTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFromViewIdType()
-	 * @generated
-	 */
-	int FROM_VIEW_ID_TYPE = 49;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.IconTypeImpl <em>Icon Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.IconTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getIconType()
-	 * @generated
-	 */
-	int ICON_TYPE = 50;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.IfTypeImpl <em>If Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.IfTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getIfType()
-	 * @generated
-	 */
-	int IF_TYPE = 51;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.KeyClassTypeImpl <em>Key Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.KeyClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getKeyClassType()
-	 * @generated
-	 */
-	int KEY_CLASS_TYPE = 52;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.KeyTypeImpl <em>Key Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.KeyTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getKeyType()
-	 * @generated
-	 */
-	int KEY_TYPE = 53;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LargeIconTypeImpl <em>Large Icon Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.LargeIconTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getLargeIconType()
-	 * @generated
-	 */
-	int LARGE_ICON_TYPE = 54;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LifecycleFactoryTypeImpl <em>Lifecycle Factory Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.LifecycleFactoryTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getLifecycleFactoryType()
-	 * @generated
-	 */
-	int LIFECYCLE_FACTORY_TYPE = 55;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LifecycleTypeImpl <em>Lifecycle Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.LifecycleTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getLifecycleType()
-	 * @generated
-	 */
-	int LIFECYCLE_TYPE = 56;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ListEntriesTypeImpl <em>List Entries Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ListEntriesTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getListEntriesType()
-	 * @generated
-	 */
-	int LIST_ENTRIES_TYPE = 58;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LocaleConfigTypeImpl <em>Locale Config Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.LocaleConfigTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getLocaleConfigType()
-	 * @generated
-	 */
-	int LOCALE_CONFIG_TYPE = 59;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanClassTypeImpl <em>Managed Bean Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getManagedBeanClassType()
-	 * @generated
-	 */
-	int MANAGED_BEAN_CLASS_TYPE = 60;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanNameTypeImpl <em>Managed Bean Name Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanNameTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getManagedBeanNameType()
-	 * @generated
-	 */
-	int MANAGED_BEAN_NAME_TYPE = 61;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanScopeTypeImpl <em>Managed Bean Scope Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanScopeTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getManagedBeanScopeType()
-	 * @generated
-	 */
-	int MANAGED_BEAN_SCOPE_TYPE = 62;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanTypeImpl <em>Managed Bean Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getManagedBeanType()
-	 * @generated
-	 */
-	int MANAGED_BEAN_TYPE = 63;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedPropertyTypeImpl <em>Managed Property Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedPropertyTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getManagedPropertyType()
-	 * @generated
-	 */
-	int MANAGED_PROPERTY_TYPE = 65;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.MapEntriesTypeImpl <em>Map Entries Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.MapEntriesTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getMapEntriesType()
-	 * @generated
-	 */
-	int MAP_ENTRIES_TYPE = 66;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.MapEntryTypeImpl <em>Map Entry Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.MapEntryTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getMapEntryType()
-	 * @generated
-	 */
-	int MAP_ENTRY_TYPE = 67;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.MessageBundleTypeImpl <em>Message Bundle Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.MessageBundleTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getMessageBundleType()
-	 * @generated
-	 */
-	int MESSAGE_BUNDLE_TYPE = 68;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NameTypeImpl <em>Name Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.NameTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getNameType()
-	 * @generated
-	 */
-	int NAME_TYPE = 69;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationCaseTypeImpl <em>Navigation Case Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationCaseTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getNavigationCaseType()
-	 * @generated
-	 */
-	int NAVIGATION_CASE_TYPE = 70;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationHandlerTypeImpl <em>Navigation Handler Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationHandlerTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getNavigationHandlerType()
-	 * @generated
-	 */
-	int NAVIGATION_HANDLER_TYPE = 71;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationRuleTypeImpl <em>Navigation Rule Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationRuleTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getNavigationRuleType()
-	 * @generated
-	 */
-	int NAVIGATION_RULE_TYPE = 72;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NullValueTypeImpl <em>Null Value Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.NullValueTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getNullValueType()
-	 * @generated
-	 */
-	int NULL_VALUE_TYPE = 74;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.OrderingTypeImpl <em>Ordering Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.OrderingTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getOrderingType()
-	 * @generated
-	 */
-	int ORDERING_TYPE = 75;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.OrderingOrderingTypeImpl <em>Ordering Ordering Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.OrderingOrderingTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getOrderingOrderingType()
-	 * @generated
-	 */
-	int ORDERING_ORDERING_TYPE = 76;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.OrderingOthersTypeImpl <em>Ordering Others Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.OrderingOthersTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getOrderingOthersType()
-	 * @generated
-	 */
-	int ORDERING_OTHERS_TYPE = 77;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PartialViewContextFactoryTypeImpl <em>Partial View Context Factory Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.PartialViewContextFactoryTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getPartialViewContextFactoryType()
-	 * @generated
-	 */
-	int PARTIAL_VIEW_CONTEXT_FACTORY_TYPE = 78;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PhaseListenerTypeImpl <em>Phase Listener Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.PhaseListenerTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getPhaseListenerType()
-	 * @generated
-	 */
-	int PHASE_LISTENER_TYPE = 79;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyClassTypeImpl <em>Property Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getPropertyClassType()
-	 * @generated
-	 */
-	int PROPERTY_CLASS_TYPE = 80;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyExtensionTypeImpl <em>Property Extension Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyExtensionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getPropertyExtensionType()
-	 * @generated
-	 */
-	int PROPERTY_EXTENSION_TYPE = 81;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyNameTypeImpl <em>Property Name Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyNameTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getPropertyNameType()
-	 * @generated
-	 */
-	int PROPERTY_NAME_TYPE = 82;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyResolverTypeImpl <em>Property Resolver Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyResolverTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getPropertyResolverType()
-	 * @generated
-	 */
-	int PROPERTY_RESOLVER_TYPE = 83;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyTypeImpl <em>Property Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getPropertyType()
-	 * @generated
-	 */
-	int PROPERTY_TYPE = 84;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RedirectTypeImpl <em>Redirect Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RedirectTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRedirectType()
-	 * @generated
-	 */
-	int REDIRECT_TYPE = 85;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RedirectViewParamTypeImpl <em>Redirect View Param Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RedirectViewParamTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRedirectViewParamType()
-	 * @generated
-	 */
-	int REDIRECT_VIEW_PARAM_TYPE = 86;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanClassTypeImpl <em>Referenced Bean Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getReferencedBeanClassType()
-	 * @generated
-	 */
-	int REFERENCED_BEAN_CLASS_TYPE = 87;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanNameTypeImpl <em>Referenced Bean Name Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanNameTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getReferencedBeanNameType()
-	 * @generated
-	 */
-	int REFERENCED_BEAN_NAME_TYPE = 88;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanTypeImpl <em>Referenced Bean Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getReferencedBeanType()
-	 * @generated
-	 */
-	int REFERENCED_BEAN_TYPE = 89;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererClassTypeImpl <em>Renderer Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RendererClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRendererClassType()
-	 * @generated
-	 */
-	int RENDERER_CLASS_TYPE = 90;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererExtensionTypeImpl <em>Renderer Extension Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RendererExtensionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRendererExtensionType()
-	 * @generated
-	 */
-	int RENDERER_EXTENSION_TYPE = 91;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeImpl <em>Renderer Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRendererType()
-	 * @generated
-	 */
-	int RENDERER_TYPE = 92;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeTypeImpl <em>Renderer Type Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRendererTypeType()
-	 * @generated
-	 */
-	int RENDERER_TYPE_TYPE = 93;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitClassTypeImpl <em>Render Kit Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRenderKitClassType()
-	 * @generated
-	 */
-	int RENDER_KIT_CLASS_TYPE = 94;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitFactoryTypeImpl <em>Render Kit Factory Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitFactoryTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRenderKitFactoryType()
-	 * @generated
-	 */
-	int RENDER_KIT_FACTORY_TYPE = 95;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitIdTypeImpl <em>Render Kit Id Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitIdTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRenderKitIdType()
-	 * @generated
-	 */
-	int RENDER_KIT_ID_TYPE = 96;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitTypeImpl <em>Render Kit Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRenderKitType()
-	 * @generated
-	 */
-	int RENDER_KIT_TYPE = 97;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SmallIconTypeImpl <em>Small Icon Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.SmallIconTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getSmallIconType()
-	 * @generated
-	 */
-	int SMALL_ICON_TYPE = 100;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SourceClassTypeImpl <em>Source Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.SourceClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getSourceClassType()
-	 * @generated
-	 */
-	int SOURCE_CLASS_TYPE = 101;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.StateManagerTypeImpl <em>State Manager Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.StateManagerTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getStateManagerType()
-	 * @generated
-	 */
-	int STATE_MANAGER_TYPE = 102;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SuggestedValueTypeImpl <em>Suggested Value Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.SuggestedValueTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getSuggestedValueType()
-	 * @generated
-	 */
-	int SUGGESTED_VALUE_TYPE = 103;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SupportedLocaleTypeImpl <em>Supported Locale Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.SupportedLocaleTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getSupportedLocaleType()
-	 * @generated
-	 */
-	int SUPPORTED_LOCALE_TYPE = 104;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SystemEventClassTypeImpl <em>System Event Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.SystemEventClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getSystemEventClassType()
-	 * @generated
-	 */
-	int SYSTEM_EVENT_CLASS_TYPE = 105;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SystemEventListenerClassTypeImpl <em>System Event Listener Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.SystemEventListenerClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getSystemEventListenerClassType()
-	 * @generated
-	 */
-	int SYSTEM_EVENT_LISTENER_CLASS_TYPE = 106;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SystemEventListenerTypeImpl <em>System Event Listener Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.SystemEventListenerTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getSystemEventListenerType()
-	 * @generated
-	 */
-	int SYSTEM_EVENT_LISTENER_TYPE = 107;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.TagHandlerDelegateFactoryTypeImpl <em>Tag Handler Delegate Factory Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.TagHandlerDelegateFactoryTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getTagHandlerDelegateFactoryType()
-	 * @generated
-	 */
-	int TAG_HANDLER_DELEGATE_FACTORY_TYPE = 108;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ToViewIdTypeImpl <em>To View Id Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ToViewIdTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getToViewIdType()
-	 * @generated
-	 */
-	int TO_VIEW_ID_TYPE = 109;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorClassTypeImpl <em>Validator Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getValidatorClassType()
-	 * @generated
-	 */
-	int VALIDATOR_CLASS_TYPE = 110;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorIdTypeImpl <em>Validator Id Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorIdTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getValidatorIdType()
-	 * @generated
-	 */
-	int VALIDATOR_ID_TYPE = 111;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorTypeImpl <em>Validator Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getValidatorType()
-	 * @generated
-	 */
-	int VALIDATOR_TYPE = 112;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValueClassTypeImpl <em>Value Class Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ValueClassTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getValueClassType()
-	 * @generated
-	 */
-	int VALUE_CLASS_TYPE = 114;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValueTypeImpl <em>Value Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ValueTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getValueType()
-	 * @generated
-	 */
-	int VALUE_TYPE = 115;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.VariableResolverTypeImpl <em>Variable Resolver Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.VariableResolverTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getVariableResolverType()
-	 * @generated
-	 */
-	int VARIABLE_RESOLVER_TYPE = 116;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ViewHandlerTypeImpl <em>View Handler Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ViewHandlerTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getViewHandlerType()
-	 * @generated
-	 */
-	int VIEW_HANDLER_TYPE = 117;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationExtensionTypeImpl <em>Application Extension Type</em>}' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationExtensionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getApplicationExtensionType()
-	 * @generated
-	 */
-    int APPLICATION_EXTENSION_TYPE = 4;
-
-    /**
-	 * The feature id for the '<em><b>Child Nodes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int APPLICATION_EXTENSION_TYPE__CHILD_NODES = EXTENSION_TYPE__CHILD_NODES;
-
-    /**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int APPLICATION_EXTENSION_TYPE__TEXT_CONTENT = EXTENSION_TYPE__TEXT_CONTENT;
-
-    /**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int APPLICATION_EXTENSION_TYPE__ID = EXTENSION_TYPE__ID;
-
-    /**
-	 * The number of structural features of the '<em>Application Extension Type</em>' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int APPLICATION_EXTENSION_TYPE_FEATURE_COUNT = EXTENSION_TYPE_FEATURE_COUNT + 0;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ATTRIBUTE_CLASS_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ATTRIBUTE_CLASS_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Attribute Class Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ATTRIBUTE_CLASS_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Child Nodes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int ATTRIBUTE_EXTENSION_TYPE__CHILD_NODES = EXTENSION_TYPE__CHILD_NODES;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int ATTRIBUTE_EXTENSION_TYPE__TEXT_CONTENT = EXTENSION_TYPE__TEXT_CONTENT;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ATTRIBUTE_EXTENSION_TYPE__ID = EXTENSION_TYPE__ID;
-
-				/**
-	 * The number of structural features of the '<em>Attribute Extension Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ATTRIBUTE_EXTENSION_TYPE_FEATURE_COUNT = EXTENSION_TYPE_FEATURE_COUNT + 0;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ATTRIBUTE_NAME_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ATTRIBUTE_NAME_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Attribute Name Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ATTRIBUTE_NAME_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Description</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ATTRIBUTE_TYPE__DESCRIPTION = 0;
-
-				/**
-	 * The feature id for the '<em><b>Display Name</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ATTRIBUTE_TYPE__DISPLAY_NAME = 1;
-
-				/**
-	 * The feature id for the '<em><b>Icon</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ATTRIBUTE_TYPE__ICON = 2;
-
-				/**
-	 * The feature id for the '<em><b>Attribute Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ATTRIBUTE_TYPE__ATTRIBUTE_NAME = 3;
-
-				/**
-	 * The feature id for the '<em><b>Attribute Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ATTRIBUTE_TYPE__ATTRIBUTE_CLASS = 4;
-
-				/**
-	 * The feature id for the '<em><b>Default Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ATTRIBUTE_TYPE__DEFAULT_VALUE = 5;
-
-				/**
-	 * The feature id for the '<em><b>Suggested Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ATTRIBUTE_TYPE__SUGGESTED_VALUE = 6;
-
-				/**
-	 * The feature id for the '<em><b>Attribute Extension</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ATTRIBUTE_TYPE__ATTRIBUTE_EXTENSION = 7;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ATTRIBUTE_TYPE__ID = 8;
-
-				/**
-	 * The number of structural features of the '<em>Attribute Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ATTRIBUTE_TYPE_FEATURE_COUNT = 9;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEHAVIOR_CLASS_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEHAVIOR_CLASS_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Behavior Class Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEHAVIOR_CLASS_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEHAVIOR_ID_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEHAVIOR_ID_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Behavior Id Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEHAVIOR_ID_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Description</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEHAVIOR_TYPE__DESCRIPTION = 0;
-
-				/**
-	 * The feature id for the '<em><b>Display Name</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEHAVIOR_TYPE__DISPLAY_NAME = 1;
-
-				/**
-	 * The feature id for the '<em><b>Icon</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEHAVIOR_TYPE__ICON = 2;
-
-				/**
-	 * The feature id for the '<em><b>Behavior Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEHAVIOR_TYPE__BEHAVIOR_ID = 3;
-
-				/**
-	 * The feature id for the '<em><b>Behavior Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEHAVIOR_TYPE__BEHAVIOR_CLASS = 4;
-
-				/**
-	 * The feature id for the '<em><b>Attribute</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEHAVIOR_TYPE__ATTRIBUTE = 5;
-
-				/**
-	 * The feature id for the '<em><b>Property</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEHAVIOR_TYPE__PROPERTY = 6;
-
-				/**
-	 * The feature id for the '<em><b>Behavior Extension</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEHAVIOR_TYPE__BEHAVIOR_EXTENSION = 7;
-
-				/**
-	 * The number of structural features of the '<em>Behavior Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEHAVIOR_TYPE_FEATURE_COUNT = 8;
-
-				/**
-	 * The feature id for the '<em><b>Child Nodes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEHAVIOR_EXTENSION_TYPE__CHILD_NODES = EXTENSION_TYPE__CHILD_NODES;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEHAVIOR_EXTENSION_TYPE__TEXT_CONTENT = EXTENSION_TYPE__TEXT_CONTENT;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEHAVIOR_EXTENSION_TYPE__ID = EXTENSION_TYPE__ID;
-
-				/**
-	 * The number of structural features of the '<em>Behavior Extension Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int BEHAVIOR_EXTENSION_TYPE_FEATURE_COUNT = EXTENSION_TYPE_FEATURE_COUNT + 0;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Client Behavior Renderer Class Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Client Behavior Renderer Type</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_TYPE = 0;
-
-				/**
-	 * The feature id for the '<em><b>Client Behavior Renderer Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_CLASS = 1;
-
-				/**
-	 * The number of structural features of the '<em>Client Behavior Renderer Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CLIENT_BEHAVIOR_RENDERER_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Client Behavior Renderer Type Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_CLASS_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_CLASS_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Component Class Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_CLASS_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Child Nodes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int COMPONENT_EXTENSION_TYPE__CHILD_NODES = EXTENSION_TYPE__CHILD_NODES;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int COMPONENT_EXTENSION_TYPE__TEXT_CONTENT = EXTENSION_TYPE__TEXT_CONTENT;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_EXTENSION_TYPE__ID = EXTENSION_TYPE__ID;
-
-				/**
-	 * The number of structural features of the '<em>Component Extension Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_EXTENSION_TYPE_FEATURE_COUNT = EXTENSION_TYPE_FEATURE_COUNT + 0;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_FAMILY_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_FAMILY_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Component Family Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_FAMILY_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Description</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_TYPE__DESCRIPTION = 0;
-
-				/**
-	 * The feature id for the '<em><b>Display Name</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_TYPE__DISPLAY_NAME = 1;
-
-				/**
-	 * The feature id for the '<em><b>Icon</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_TYPE__ICON = 2;
-
-				/**
-	 * The feature id for the '<em><b>Component Type</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_TYPE__COMPONENT_TYPE = 3;
-
-				/**
-	 * The feature id for the '<em><b>Component Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_TYPE__COMPONENT_CLASS = 4;
-
-				/**
-	 * The feature id for the '<em><b>Facet</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_TYPE__FACET = 5;
-
-				/**
-	 * The feature id for the '<em><b>Attribute</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_TYPE__ATTRIBUTE = 6;
-
-				/**
-	 * The feature id for the '<em><b>Property</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_TYPE__PROPERTY = 7;
-
-				/**
-	 * The feature id for the '<em><b>Component Extension</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_TYPE__COMPONENT_EXTENSION = 8;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_TYPE__ID = 9;
-
-				/**
-	 * The number of structural features of the '<em>Component Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_TYPE_FEATURE_COUNT = 10;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_TYPE_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_TYPE_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Component Type Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COMPONENT_TYPE_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CONVERTER_CLASS_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CONVERTER_CLASS_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Converter Class Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CONVERTER_CLASS_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CONVERTER_FOR_CLASS_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CONVERTER_FOR_CLASS_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Converter For Class Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CONVERTER_FOR_CLASS_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CONVERTER_ID_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CONVERTER_ID_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Converter Id Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CONVERTER_ID_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Description</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CONVERTER_TYPE__DESCRIPTION = 0;
-
-				/**
-	 * The feature id for the '<em><b>Display Name</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CONVERTER_TYPE__DISPLAY_NAME = 1;
-
-				/**
-	 * The feature id for the '<em><b>Icon</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CONVERTER_TYPE__ICON = 2;
-
-				/**
-	 * The feature id for the '<em><b>Converter Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CONVERTER_TYPE__CONVERTER_ID = 3;
-
-				/**
-	 * The feature id for the '<em><b>Converter For Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CONVERTER_TYPE__CONVERTER_FOR_CLASS = 4;
-
-				/**
-	 * The feature id for the '<em><b>Converter Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CONVERTER_TYPE__CONVERTER_CLASS = 5;
-
-				/**
-	 * The feature id for the '<em><b>Attribute</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CONVERTER_TYPE__ATTRIBUTE = 6;
-
-				/**
-	 * The feature id for the '<em><b>Property</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CONVERTER_TYPE__PROPERTY = 7;
-
-				/**
-	 * The feature id for the '<em><b>Converter Extension</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int CONVERTER_TYPE__CONVERTER_EXTENSION = 8;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CONVERTER_TYPE__ID = 9;
-
-				/**
-	 * The number of structural features of the '<em>Converter Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int CONVERTER_TYPE_FEATURE_COUNT = 10;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ResourceBundleTypeImpl <em>Resource Bundle Type</em>}' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ResourceBundleTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getResourceBundleType()
-	 * @generated
-	 */
-    int RESOURCE_BUNDLE_TYPE = 118;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BaseNameTypeImpl <em>Base Name Type</em>}' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.BaseNameTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getBaseNameType()
-	 * @generated
-	 */
-    int BASE_NAME_TYPE = 119;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.VarTypeImpl <em>Var Type</em>}' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.VarTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getVarType()
-	 * @generated
-	 */
-    int VAR_TYPE = 120;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigExtensionTypeImpl <em>Extension Type</em>}' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigExtensionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFacesConfigExtensionType()
-	 * @generated
-	 */
-    int FACES_CONFIG_EXTENSION_TYPE = 40;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryExtensionTypeImpl <em>Factory Extension Type</em>}' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryExtensionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFactoryExtensionType()
-	 * @generated
-	 */
-    int FACTORY_EXTENSION_TYPE = 46;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LifecycleExtensionTypeImpl <em>Lifecycle Extension Type</em>}' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.LifecycleExtensionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getLifecycleExtensionType()
-	 * @generated
-	 */
-    int LIFECYCLE_EXTENSION_TYPE = 57;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterExtensionTypeImpl <em>Converter Extension Type</em>}' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterExtensionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getConverterExtensionType()
-	 * @generated
-	 */
-    int CONVERTER_EXTENSION_TYPE = 25;
-
-    /**
-	 * The feature id for the '<em><b>Child Nodes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int CONVERTER_EXTENSION_TYPE__CHILD_NODES = EXTENSION_TYPE__CHILD_NODES;
-
-    /**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int CONVERTER_EXTENSION_TYPE__TEXT_CONTENT = EXTENSION_TYPE__TEXT_CONTENT;
-
-    /**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int CONVERTER_EXTENSION_TYPE__ID = EXTENSION_TYPE__ID;
-
-    /**
-	 * The number of structural features of the '<em>Converter Extension Type</em>' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int CONVERTER_EXTENSION_TYPE_FEATURE_COUNT = EXTENSION_TYPE_FEATURE_COUNT + 0;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DEFAULT_LOCALE_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DEFAULT_LOCALE_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Default Locale Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DEFAULT_LOCALE_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DEFAULT_RENDER_KIT_ID_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DEFAULT_RENDER_KIT_ID_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Default Render Kit Id Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DEFAULT_RENDER_KIT_ID_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Validator Id</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DEFAULT_VALIDATORS_TYPE__VALIDATOR_ID = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DEFAULT_VALIDATORS_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Default Validators Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DEFAULT_VALIDATORS_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DEFAULT_VALUE_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DEFAULT_VALUE_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Default Value Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DEFAULT_VALUE_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DESCRIPTION_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Lang</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DESCRIPTION_TYPE__LANG = 1;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DESCRIPTION_TYPE__ID = 2;
-
-				/**
-	 * The number of structural features of the '<em>Description Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DESCRIPTION_TYPE_FEATURE_COUNT = 3;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DISPLAY_NAME_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Lang</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DISPLAY_NAME_TYPE__LANG = 1;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DISPLAY_NAME_TYPE__ID = 2;
-
-				/**
-	 * The number of structural features of the '<em>Display Name Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DISPLAY_NAME_TYPE_FEATURE_COUNT = 3;
-
-				/**
-	 * The feature id for the '<em><b>Mixed</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__MIXED = 0;
-
-				/**
-	 * The feature id for the '<em><b>XMLNS Prefix Map</b></em>' map.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__XMLNS_PREFIX_MAP = 1;
-
-				/**
-	 * The feature id for the '<em><b>XSI Schema Location</b></em>' map.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__XSI_SCHEMA_LOCATION = 2;
-
-				/**
-	 * The feature id for the '<em><b>Absolute Ordering</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__ABSOLUTE_ORDERING = 3;
-
-				/**
-	 * The feature id for the '<em><b>Action Listener</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__ACTION_LISTENER = 4;
-
-				/**
-	 * The feature id for the '<em><b>Application</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__APPLICATION = 5;
-
-				/**
-	 * The feature id for the '<em><b>Application Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__APPLICATION_FACTORY = 6;
-
-				/**
-	 * The feature id for the '<em><b>Attribute</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__ATTRIBUTE = 7;
-
-				/**
-	 * The feature id for the '<em><b>Attribute Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__ATTRIBUTE_CLASS = 8;
-
-				/**
-	 * The feature id for the '<em><b>Attribute Extension</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__ATTRIBUTE_EXTENSION = 9;
-
-				/**
-	 * The feature id for the '<em><b>Attribute Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__ATTRIBUTE_NAME = 10;
-
-				/**
-	 * The feature id for the '<em><b>Behavior</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__BEHAVIOR = 11;
-
-				/**
-	 * The feature id for the '<em><b>Behavior Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__BEHAVIOR_CLASS = 12;
-
-				/**
-	 * The feature id for the '<em><b>Behavior Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__BEHAVIOR_ID = 13;
-
-				/**
-	 * The feature id for the '<em><b>Behavior Extension</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__BEHAVIOR_EXTENSION = 14;
-
-				/**
-	 * The feature id for the '<em><b>Component</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__COMPONENT = 15;
-
-				/**
-	 * The feature id for the '<em><b>Component Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__COMPONENT_CLASS = 16;
-
-				/**
-	 * The feature id for the '<em><b>Component Extension</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__COMPONENT_EXTENSION = 17;
-
-				/**
-	 * The feature id for the '<em><b>Component Family</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__COMPONENT_FAMILY = 18;
-
-				/**
-	 * The feature id for the '<em><b>Component Type</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__COMPONENT_TYPE = 19;
-
-				/**
-	 * The feature id for the '<em><b>Converter</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__CONVERTER = 20;
-
-				/**
-	 * The feature id for the '<em><b>Converter Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__CONVERTER_CLASS = 21;
-
-				/**
-	 * The feature id for the '<em><b>Converter For Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__CONVERTER_FOR_CLASS = 22;
-
-				/**
-	 * The feature id for the '<em><b>Converter Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__CONVERTER_ID = 23;
-
-				/**
-	 * The feature id for the '<em><b>Default Locale</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__DEFAULT_LOCALE = 24;
-
-				/**
-	 * The feature id for the '<em><b>Default Render Kit Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__DEFAULT_RENDER_KIT_ID = 25;
-
-				/**
-	 * The feature id for the '<em><b>Default Validators</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__DEFAULT_VALIDATORS = 26;
-
-				/**
-	 * The feature id for the '<em><b>Default Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__DEFAULT_VALUE = 27;
-
-				/**
-	 * The feature id for the '<em><b>Description</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__DESCRIPTION = 28;
-
-				/**
-	 * The feature id for the '<em><b>Display Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__DISPLAY_NAME = 29;
-
-				/**
-	 * The feature id for the '<em><b>Exception Handler Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__EXCEPTION_HANDLER_FACTORY = 30;
-
-				/**
-	 * The feature id for the '<em><b>External Context Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__EXTERNAL_CONTEXT_FACTORY = 31;
-
-				/**
-	 * The feature id for the '<em><b>Faces Config</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__FACES_CONFIG = 32;
-
-				/**
-	 * The feature id for the '<em><b>Faces Context Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__FACES_CONTEXT_FACTORY = 33;
-
-				/**
-	 * The feature id for the '<em><b>Facet</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__FACET = 34;
-
-				/**
-	 * The feature id for the '<em><b>Facet Extension</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__FACET_EXTENSION = 35;
-
-				/**
-	 * The feature id for the '<em><b>Facet Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__FACET_NAME = 36;
-
-				/**
-	 * The feature id for the '<em><b>Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__FACTORY = 37;
-
-				/**
-	 * The feature id for the '<em><b>From Action</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__FROM_ACTION = 38;
-
-				/**
-	 * The feature id for the '<em><b>From Outcome</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__FROM_OUTCOME = 39;
-
-				/**
-	 * The feature id for the '<em><b>From View Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__FROM_VIEW_ID = 40;
-
-				/**
-	 * The feature id for the '<em><b>Icon</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__ICON = 41;
-
-				/**
-	 * The feature id for the '<em><b>If</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__IF = 42;
-
-				/**
-	 * The feature id for the '<em><b>Key</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__KEY = 43;
-
-				/**
-	 * The feature id for the '<em><b>Key Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__KEY_CLASS = 44;
-
-				/**
-	 * The feature id for the '<em><b>Large Icon</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__LARGE_ICON = 45;
-
-				/**
-	 * The feature id for the '<em><b>Lifecycle</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__LIFECYCLE = 46;
-
-				/**
-	 * The feature id for the '<em><b>Lifecycle Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__LIFECYCLE_FACTORY = 47;
-
-				/**
-	 * The feature id for the '<em><b>List Entries</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__LIST_ENTRIES = 48;
-
-				/**
-	 * The feature id for the '<em><b>Locale Config</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__LOCALE_CONFIG = 49;
-
-				/**
-	 * The feature id for the '<em><b>Managed Bean</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__MANAGED_BEAN = 50;
-
-				/**
-	 * The feature id for the '<em><b>Managed Bean Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__MANAGED_BEAN_CLASS = 51;
-
-				/**
-	 * The feature id for the '<em><b>Managed Bean Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__MANAGED_BEAN_NAME = 52;
-
-				/**
-	 * The feature id for the '<em><b>Managed Bean Scope</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__MANAGED_BEAN_SCOPE = 53;
-
-				/**
-	 * The feature id for the '<em><b>Managed Property</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__MANAGED_PROPERTY = 54;
-
-				/**
-	 * The feature id for the '<em><b>Map Entries</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__MAP_ENTRIES = 55;
-
-				/**
-	 * The feature id for the '<em><b>Map Entry</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__MAP_ENTRY = 56;
-
-				/**
-	 * The feature id for the '<em><b>Message Bundle</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__MESSAGE_BUNDLE = 57;
-
-				/**
-	 * The feature id for the '<em><b>Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__NAME = 58;
-
-				/**
-	 * The feature id for the '<em><b>Navigation Case</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__NAVIGATION_CASE = 59;
-
-				/**
-	 * The feature id for the '<em><b>Navigation Handler</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__NAVIGATION_HANDLER = 60;
-
-				/**
-	 * The feature id for the '<em><b>Navigation Rule</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__NAVIGATION_RULE = 61;
-
-				/**
-	 * The feature id for the '<em><b>Null Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__NULL_VALUE = 62;
-
-				/**
-	 * The feature id for the '<em><b>Ordering</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__ORDERING = 63;
-
-				/**
-	 * The feature id for the '<em><b>Ordering Ordering</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__ORDERING_ORDERING = 64;
-
-				/**
-	 * The feature id for the '<em><b>Others</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__OTHERS = 65;
-
-				/**
-	 * The feature id for the '<em><b>Partial View Context Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__PARTIAL_VIEW_CONTEXT_FACTORY = 66;
-
-				/**
-	 * The feature id for the '<em><b>Phase Listener</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__PHASE_LISTENER = 67;
-
-				/**
-	 * The feature id for the '<em><b>Property</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__PROPERTY = 68;
-
-				/**
-	 * The feature id for the '<em><b>Property Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__PROPERTY_CLASS = 69;
-
-				/**
-	 * The feature id for the '<em><b>Property Extension</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__PROPERTY_EXTENSION = 70;
-
-				/**
-	 * The feature id for the '<em><b>Property Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__PROPERTY_NAME = 71;
-
-				/**
-	 * The feature id for the '<em><b>Property Resolver</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__PROPERTY_RESOLVER = 72;
-
-				/**
-	 * The feature id for the '<em><b>Redirect</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__REDIRECT = 73;
-
-				/**
-	 * The feature id for the '<em><b>Redirect View Param</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__REDIRECT_VIEW_PARAM = 74;
-
-				/**
-	 * The feature id for the '<em><b>Referenced Bean</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__REFERENCED_BEAN = 75;
-
-				/**
-	 * The feature id for the '<em><b>Referenced Bean Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__REFERENCED_BEAN_CLASS = 76;
-
-				/**
-	 * The feature id for the '<em><b>Referenced Bean Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__REFERENCED_BEAN_NAME = 77;
-
-				/**
-	 * The feature id for the '<em><b>Renderer</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__RENDERER = 78;
-
-				/**
-	 * The feature id for the '<em><b>Renderer Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__RENDERER_CLASS = 79;
-
-				/**
-	 * The feature id for the '<em><b>Renderer Extension</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__RENDERER_EXTENSION = 80;
-
-				/**
-	 * The feature id for the '<em><b>Renderer Type</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__RENDERER_TYPE = 81;
-
-				/**
-	 * The feature id for the '<em><b>Render Kit</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__RENDER_KIT = 82;
-
-				/**
-	 * The feature id for the '<em><b>Render Kit Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__RENDER_KIT_CLASS = 83;
-
-				/**
-	 * The feature id for the '<em><b>Render Kit Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__RENDER_KIT_FACTORY = 84;
-
-				/**
-	 * The feature id for the '<em><b>Render Kit Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__RENDER_KIT_ID = 85;
-
-				/**
-	 * The feature id for the '<em><b>Resource Handler</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__RESOURCE_HANDLER = 86;
-
-				/**
-	 * The feature id for the '<em><b>Small Icon</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__SMALL_ICON = 87;
-
-				/**
-	 * The feature id for the '<em><b>Source Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__SOURCE_CLASS = 88;
-
-				/**
-	 * The feature id for the '<em><b>State Manager</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__STATE_MANAGER = 89;
-
-				/**
-	 * The feature id for the '<em><b>Suggested Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__SUGGESTED_VALUE = 90;
-
-				/**
-	 * The feature id for the '<em><b>Supported Locale</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__SUPPORTED_LOCALE = 91;
-
-				/**
-	 * The feature id for the '<em><b>System Event Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__SYSTEM_EVENT_CLASS = 92;
-
-				/**
-	 * The feature id for the '<em><b>System Event Listener</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER = 93;
-
-				/**
-	 * The feature id for the '<em><b>System Event Listener Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER_CLASS = 94;
-
-				/**
-	 * The feature id for the '<em><b>Tag Handler Delegate Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__TAG_HANDLER_DELEGATE_FACTORY = 95;
-
-				/**
-	 * The feature id for the '<em><b>To View Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__TO_VIEW_ID = 96;
-
-				/**
-	 * The feature id for the '<em><b>Validator</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__VALIDATOR = 97;
-
-				/**
-	 * The feature id for the '<em><b>Validator Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__VALIDATOR_CLASS = 98;
-
-				/**
-	 * The feature id for the '<em><b>Validator Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__VALIDATOR_ID = 99;
-
-				/**
-	 * The feature id for the '<em><b>Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__VALUE = 100;
-
-				/**
-	 * The feature id for the '<em><b>Value Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__VALUE_CLASS = 101;
-
-				/**
-	 * The feature id for the '<em><b>Variable Resolver</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__VARIABLE_RESOLVER = 102;
-
-				/**
-	 * The feature id for the '<em><b>View Declaration Language Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__VIEW_DECLARATION_LANGUAGE_FACTORY = 103;
-
-				/**
-	 * The feature id for the '<em><b>View Handler</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__VIEW_HANDLER = 104;
-
-				/**
-	 * The feature id for the '<em><b>Visit Context Factory</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT__VISIT_CONTEXT_FACTORY = 105;
-
-				/**
-	 * The number of structural features of the '<em>Document Root</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int DOCUMENT_ROOT_FEATURE_COUNT = 106;
-
-				/**
-	 * The feature id for the '<em><b>Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int DYNAMIC_ATTRIBUTE__NAME = 0;
-
-				/**
-	 * The feature id for the '<em><b>Value</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int DYNAMIC_ATTRIBUTE__VALUE = 1;
-
-				/**
-	 * The number of structural features of the '<em>Dynamic Attribute</em>' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int DYNAMIC_ATTRIBUTE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Child Nodes</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int DYNAMIC_ELEMENT__CHILD_NODES = 0;
-
-				/**
-	 * The feature id for the '<em><b>Name</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int DYNAMIC_ELEMENT__NAME = 1;
-
-				/**
-	 * The feature id for the '<em><b>Attributes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int DYNAMIC_ELEMENT__ATTRIBUTES = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int DYNAMIC_ELEMENT__TEXT_CONTENT = 3;
-
-				/**
-	 * The number of structural features of the '<em>Dynamic Element</em>' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int DYNAMIC_ELEMENT_FEATURE_COUNT = 4;
-
-
-    /**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int EL_RESOLVER_TYPE__TEXT_CONTENT = 0;
-
-    /**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int EL_RESOLVER_TYPE__ID = 1;
-
-    /**
-	 * The number of structural features of the '<em>EL Resolver Type</em>' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int EL_RESOLVER_TYPE_FEATURE_COUNT = 2;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ExceptionHandlerFactoryTypeImpl <em>Exception Handler Factory Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ExceptionHandlerFactoryTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getExceptionHandlerFactoryType()
-	 * @generated
-	 */
-	int EXCEPTION_HANDLER_FACTORY_TYPE = 36;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXCEPTION_HANDLER_FACTORY_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXCEPTION_HANDLER_FACTORY_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Exception Handler Factory Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXCEPTION_HANDLER_FACTORY_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ExternalContextFactoryTypeImpl <em>External Context Factory Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ExternalContextFactoryTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getExternalContextFactoryType()
-	 * @generated
-	 */
-	int EXTERNAL_CONTEXT_FACTORY_TYPE = 38;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXTERNAL_CONTEXT_FACTORY_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXTERNAL_CONTEXT_FACTORY_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>External Context Factory Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int EXTERNAL_CONTEXT_FACTORY_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Application</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACES_CONFIG_TYPE__APPLICATION = 0;
-
-				/**
-	 * The feature id for the '<em><b>Ordering</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACES_CONFIG_TYPE__ORDERING = 1;
-
-				/**
-	 * The feature id for the '<em><b>Absolute Ordering</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACES_CONFIG_TYPE__ABSOLUTE_ORDERING = 2;
-
-				/**
-	 * The feature id for the '<em><b>Factory</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACES_CONFIG_TYPE__FACTORY = 3;
-
-				/**
-	 * The feature id for the '<em><b>Component</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACES_CONFIG_TYPE__COMPONENT = 4;
-
-				/**
-	 * The feature id for the '<em><b>Converter</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACES_CONFIG_TYPE__CONVERTER = 5;
-
-				/**
-	 * The feature id for the '<em><b>Managed Bean</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACES_CONFIG_TYPE__MANAGED_BEAN = 6;
-
-				/**
-	 * The feature id for the '<em><b>Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACES_CONFIG_TYPE__NAME = 7;
-
-				/**
-	 * The feature id for the '<em><b>Navigation Rule</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACES_CONFIG_TYPE__NAVIGATION_RULE = 8;
-
-				/**
-	 * The feature id for the '<em><b>Referenced Bean</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACES_CONFIG_TYPE__REFERENCED_BEAN = 9;
-
-				/**
-	 * The feature id for the '<em><b>Render Kit</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACES_CONFIG_TYPE__RENDER_KIT = 10;
-
-				/**
-	 * The feature id for the '<em><b>Lifecycle</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACES_CONFIG_TYPE__LIFECYCLE = 11;
-
-				/**
-	 * The feature id for the '<em><b>Validator</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACES_CONFIG_TYPE__VALIDATOR = 12;
-
-				/**
-	 * The feature id for the '<em><b>Behavior</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACES_CONFIG_TYPE__BEHAVIOR = 13;
-
-				/**
-	 * The feature id for the '<em><b>Faces Config Extension</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int FACES_CONFIG_TYPE__FACES_CONFIG_EXTENSION = 14;
-
-				/**
-	 * The feature id for the '<em><b>Xmlns</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACES_CONFIG_TYPE__XMLNS = 15;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACES_CONFIG_TYPE__ID = 16;
-
-				/**
-	 * The feature id for the '<em><b>Metadata Complete</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACES_CONFIG_TYPE__METADATA_COMPLETE = 17;
-
-				/**
-	 * The number of structural features of the '<em>Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACES_CONFIG_TYPE_FEATURE_COUNT = 18;
-
-				/**
-	 * The feature id for the '<em><b>Child Nodes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int FACES_CONFIG_EXTENSION_TYPE__CHILD_NODES = EXTENSION_TYPE__CHILD_NODES;
-
-    /**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int FACES_CONFIG_EXTENSION_TYPE__TEXT_CONTENT = EXTENSION_TYPE__TEXT_CONTENT;
-
-    /**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int FACES_CONFIG_EXTENSION_TYPE__ID = EXTENSION_TYPE__ID;
-
-    /**
-	 * The number of structural features of the '<em>Extension Type</em>' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int FACES_CONFIG_EXTENSION_TYPE_FEATURE_COUNT = EXTENSION_TYPE_FEATURE_COUNT + 0;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACES_CONTEXT_FACTORY_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACES_CONTEXT_FACTORY_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Faces Context Factory Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACES_CONTEXT_FACTORY_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Child Nodes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int FACET_EXTENSION_TYPE__CHILD_NODES = EXTENSION_TYPE__CHILD_NODES;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int FACET_EXTENSION_TYPE__TEXT_CONTENT = EXTENSION_TYPE__TEXT_CONTENT;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACET_EXTENSION_TYPE__ID = EXTENSION_TYPE__ID;
-
-				/**
-	 * The number of structural features of the '<em>Facet Extension Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACET_EXTENSION_TYPE_FEATURE_COUNT = EXTENSION_TYPE_FEATURE_COUNT + 0;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACET_NAME_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACET_NAME_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Facet Name Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACET_NAME_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Description</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACET_TYPE__DESCRIPTION = 0;
-
-				/**
-	 * The feature id for the '<em><b>Display Name</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACET_TYPE__DISPLAY_NAME = 1;
-
-				/**
-	 * The feature id for the '<em><b>Icon</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACET_TYPE__ICON = 2;
-
-				/**
-	 * The feature id for the '<em><b>Facet Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACET_TYPE__FACET_NAME = 3;
-
-				/**
-	 * The feature id for the '<em><b>Facet Extension</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACET_TYPE__FACET_EXTENSION = 4;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACET_TYPE__ID = 5;
-
-				/**
-	 * The number of structural features of the '<em>Facet Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACET_TYPE_FEATURE_COUNT = 6;
-
-				/**
-	 * The feature id for the '<em><b>Application Factory</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACTORY_TYPE__APPLICATION_FACTORY = 0;
-
-				/**
-	 * The feature id for the '<em><b>Exception Handler Factory</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACTORY_TYPE__EXCEPTION_HANDLER_FACTORY = 1;
-
-				/**
-	 * The feature id for the '<em><b>External Context Factory</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACTORY_TYPE__EXTERNAL_CONTEXT_FACTORY = 2;
-
-				/**
-	 * The feature id for the '<em><b>Faces Context Factory</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACTORY_TYPE__FACES_CONTEXT_FACTORY = 3;
-
-				/**
-	 * The feature id for the '<em><b>Partial View Context Factory</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACTORY_TYPE__PARTIAL_VIEW_CONTEXT_FACTORY = 4;
-
-				/**
-	 * The feature id for the '<em><b>Lifecycle Factory</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACTORY_TYPE__LIFECYCLE_FACTORY = 5;
-
-				/**
-	 * The feature id for the '<em><b>View Declaration Language Factory</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACTORY_TYPE__VIEW_DECLARATION_LANGUAGE_FACTORY = 6;
-
-				/**
-	 * The feature id for the '<em><b>Tag Handler Delegate Factory</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACTORY_TYPE__TAG_HANDLER_DELEGATE_FACTORY = 7;
-
-				/**
-	 * The feature id for the '<em><b>Render Kit Factory</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACTORY_TYPE__RENDER_KIT_FACTORY = 8;
-
-				/**
-	 * The feature id for the '<em><b>Visit Context Factory</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACTORY_TYPE__VISIT_CONTEXT_FACTORY = 9;
-
-				/**
-	 * The feature id for the '<em><b>Factory Extension</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int FACTORY_TYPE__FACTORY_EXTENSION = 10;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACTORY_TYPE__ID = 11;
-
-				/**
-	 * The number of structural features of the '<em>Factory Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FACTORY_TYPE_FEATURE_COUNT = 12;
-
-
-    /**
-	 * The feature id for the '<em><b>Child Nodes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int FACTORY_EXTENSION_TYPE__CHILD_NODES = EXTENSION_TYPE__CHILD_NODES;
-
-    /**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int FACTORY_EXTENSION_TYPE__TEXT_CONTENT = EXTENSION_TYPE__TEXT_CONTENT;
-
-    /**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int FACTORY_EXTENSION_TYPE__ID = EXTENSION_TYPE__ID;
-
-    /**
-	 * The number of structural features of the '<em>Factory Extension Type</em>' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int FACTORY_EXTENSION_TYPE_FEATURE_COUNT = EXTENSION_TYPE_FEATURE_COUNT + 0;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FROM_ACTION_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FROM_ACTION_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>From Action Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FROM_ACTION_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FROM_OUTCOME_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FROM_OUTCOME_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>From Outcome Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FROM_OUTCOME_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FROM_VIEW_ID_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FROM_VIEW_ID_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>From View Id Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int FROM_VIEW_ID_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Small Icon</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ICON_TYPE__SMALL_ICON = 0;
-
-				/**
-	 * The feature id for the '<em><b>Large Icon</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ICON_TYPE__LARGE_ICON = 1;
-
-				/**
-	 * The feature id for the '<em><b>Lang</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ICON_TYPE__LANG = 2;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ICON_TYPE__ID = 3;
-
-				/**
-	 * The number of structural features of the '<em>Icon Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ICON_TYPE_FEATURE_COUNT = 4;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int IF_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int IF_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>If Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int IF_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int KEY_CLASS_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int KEY_CLASS_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Key Class Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int KEY_CLASS_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int KEY_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int KEY_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Key Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int KEY_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int LARGE_ICON_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int LARGE_ICON_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Large Icon Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int LARGE_ICON_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int LIFECYCLE_FACTORY_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int LIFECYCLE_FACTORY_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Lifecycle Factory Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int LIFECYCLE_FACTORY_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Phase Listener</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int LIFECYCLE_TYPE__PHASE_LISTENER = 0;
-
-				/**
-	 * The feature id for the '<em><b>Lifecycle Extension</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int LIFECYCLE_TYPE__LIFECYCLE_EXTENSION = 1;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int LIFECYCLE_TYPE__ID = 2;
-
-				/**
-	 * The number of structural features of the '<em>Lifecycle Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int LIFECYCLE_TYPE_FEATURE_COUNT = 3;
-
-
-    /**
-	 * The feature id for the '<em><b>Child Nodes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int LIFECYCLE_EXTENSION_TYPE__CHILD_NODES = EXTENSION_TYPE__CHILD_NODES;
-
-    /**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int LIFECYCLE_EXTENSION_TYPE__TEXT_CONTENT = EXTENSION_TYPE__TEXT_CONTENT;
-
-    /**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int LIFECYCLE_EXTENSION_TYPE__ID = EXTENSION_TYPE__ID;
-
-    /**
-	 * The number of structural features of the '<em>Lifecycle Extension Type</em>' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int LIFECYCLE_EXTENSION_TYPE_FEATURE_COUNT = EXTENSION_TYPE_FEATURE_COUNT + 0;
-
-				/**
-	 * The feature id for the '<em><b>Value Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int LIST_ENTRIES_TYPE__VALUE_CLASS = 0;
-
-				/**
-	 * The feature id for the '<em><b>Null Value</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int LIST_ENTRIES_TYPE__NULL_VALUE = 1;
-
-				/**
-	 * The feature id for the '<em><b>Value</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int LIST_ENTRIES_TYPE__VALUE = 2;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int LIST_ENTRIES_TYPE__ID = 3;
-
-				/**
-	 * The number of structural features of the '<em>List Entries Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int LIST_ENTRIES_TYPE_FEATURE_COUNT = 4;
-
-				/**
-	 * The feature id for the '<em><b>Default Locale</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int LOCALE_CONFIG_TYPE__DEFAULT_LOCALE = 0;
-
-				/**
-	 * The feature id for the '<em><b>Supported Locale</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int LOCALE_CONFIG_TYPE__SUPPORTED_LOCALE = 1;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int LOCALE_CONFIG_TYPE__ID = 2;
-
-				/**
-	 * The number of structural features of the '<em>Locale Config Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int LOCALE_CONFIG_TYPE_FEATURE_COUNT = 3;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_BEAN_CLASS_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_BEAN_CLASS_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Managed Bean Class Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_BEAN_CLASS_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_BEAN_NAME_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_BEAN_NAME_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Managed Bean Name Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_BEAN_NAME_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_BEAN_SCOPE_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_BEAN_SCOPE_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Managed Bean Scope Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_BEAN_SCOPE_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Description</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_BEAN_TYPE__DESCRIPTION = 0;
-
-				/**
-	 * The feature id for the '<em><b>Display Name</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_BEAN_TYPE__DISPLAY_NAME = 1;
-
-				/**
-	 * The feature id for the '<em><b>Icon</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_BEAN_TYPE__ICON = 2;
-
-				/**
-	 * The feature id for the '<em><b>Managed Bean Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_BEAN_TYPE__MANAGED_BEAN_NAME = 3;
-
-				/**
-	 * The feature id for the '<em><b>Managed Bean Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_BEAN_TYPE__MANAGED_BEAN_CLASS = 4;
-
-				/**
-	 * The feature id for the '<em><b>Managed Bean Scope</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_BEAN_TYPE__MANAGED_BEAN_SCOPE = 5;
-
-				/**
-	 * The feature id for the '<em><b>Managed Property</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_BEAN_TYPE__MANAGED_PROPERTY = 6;
-
-				/**
-	 * The feature id for the '<em><b>Map Entries</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_BEAN_TYPE__MAP_ENTRIES = 7;
-
-				/**
-	 * The feature id for the '<em><b>List Entries</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_BEAN_TYPE__LIST_ENTRIES = 8;
-
-				/**
-	 * The feature id for the '<em><b>Managed Bean Extension</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int MANAGED_BEAN_TYPE__MANAGED_BEAN_EXTENSION = 9;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_BEAN_TYPE__ID = 10;
-
-				/**
-	 * The feature id for the '<em><b>Eager</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_BEAN_TYPE__EAGER = 11;
-
-				/**
-	 * The number of structural features of the '<em>Managed Bean Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_BEAN_TYPE_FEATURE_COUNT = 12;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanExtensionTypeImpl <em>Managed Bean Extension Type</em>}' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanExtensionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getManagedBeanExtensionType()
-	 * @generated
-	 */
-    int MANAGED_BEAN_EXTENSION_TYPE = 64;
-
-    /**
-	 * The feature id for the '<em><b>Child Nodes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int MANAGED_BEAN_EXTENSION_TYPE__CHILD_NODES = EXTENSION_TYPE__CHILD_NODES;
-
-    /**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int MANAGED_BEAN_EXTENSION_TYPE__TEXT_CONTENT = EXTENSION_TYPE__TEXT_CONTENT;
-
-    /**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int MANAGED_BEAN_EXTENSION_TYPE__ID = EXTENSION_TYPE__ID;
-
-    /**
-	 * The number of structural features of the '<em>Managed Bean Extension Type</em>' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int MANAGED_BEAN_EXTENSION_TYPE_FEATURE_COUNT = EXTENSION_TYPE_FEATURE_COUNT + 0;
-
-				/**
-	 * The feature id for the '<em><b>Description</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_PROPERTY_TYPE__DESCRIPTION = 0;
-
-				/**
-	 * The feature id for the '<em><b>Display Name</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_PROPERTY_TYPE__DISPLAY_NAME = 1;
-
-				/**
-	 * The feature id for the '<em><b>Icon</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_PROPERTY_TYPE__ICON = 2;
-
-				/**
-	 * The feature id for the '<em><b>Property Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_PROPERTY_TYPE__PROPERTY_NAME = 3;
-
-				/**
-	 * The feature id for the '<em><b>Property Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_PROPERTY_TYPE__PROPERTY_CLASS = 4;
-
-				/**
-	 * The feature id for the '<em><b>Map Entries</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_PROPERTY_TYPE__MAP_ENTRIES = 5;
-
-				/**
-	 * The feature id for the '<em><b>Null Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_PROPERTY_TYPE__NULL_VALUE = 6;
-
-				/**
-	 * The feature id for the '<em><b>Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_PROPERTY_TYPE__VALUE = 7;
-
-				/**
-	 * The feature id for the '<em><b>List Entries</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_PROPERTY_TYPE__LIST_ENTRIES = 8;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_PROPERTY_TYPE__ID = 9;
-
-				/**
-	 * The number of structural features of the '<em>Managed Property Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MANAGED_PROPERTY_TYPE_FEATURE_COUNT = 10;
-
-				/**
-	 * The feature id for the '<em><b>Key Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MAP_ENTRIES_TYPE__KEY_CLASS = 0;
-
-				/**
-	 * The feature id for the '<em><b>Value Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MAP_ENTRIES_TYPE__VALUE_CLASS = 1;
-
-				/**
-	 * The feature id for the '<em><b>Map Entry</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MAP_ENTRIES_TYPE__MAP_ENTRY = 2;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MAP_ENTRIES_TYPE__ID = 3;
-
-				/**
-	 * The number of structural features of the '<em>Map Entries Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MAP_ENTRIES_TYPE_FEATURE_COUNT = 4;
-
-				/**
-	 * The feature id for the '<em><b>Key</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MAP_ENTRY_TYPE__KEY = 0;
-
-				/**
-	 * The feature id for the '<em><b>Null Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MAP_ENTRY_TYPE__NULL_VALUE = 1;
-
-				/**
-	 * The feature id for the '<em><b>Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MAP_ENTRY_TYPE__VALUE = 2;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MAP_ENTRY_TYPE__ID = 3;
-
-				/**
-	 * The number of structural features of the '<em>Map Entry Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MAP_ENTRY_TYPE_FEATURE_COUNT = 4;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MESSAGE_BUNDLE_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MESSAGE_BUNDLE_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Message Bundle Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int MESSAGE_BUNDLE_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAME_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAME_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Name Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAME_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Description</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAVIGATION_CASE_TYPE__DESCRIPTION = 0;
-
-				/**
-	 * The feature id for the '<em><b>Display Name</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAVIGATION_CASE_TYPE__DISPLAY_NAME = 1;
-
-				/**
-	 * The feature id for the '<em><b>Icon</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAVIGATION_CASE_TYPE__ICON = 2;
-
-				/**
-	 * The feature id for the '<em><b>From Action</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAVIGATION_CASE_TYPE__FROM_ACTION = 3;
-
-				/**
-	 * The feature id for the '<em><b>From Outcome</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAVIGATION_CASE_TYPE__FROM_OUTCOME = 4;
-
-				/**
-	 * The feature id for the '<em><b>If</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAVIGATION_CASE_TYPE__IF = 5;
-
-				/**
-	 * The feature id for the '<em><b>To View Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAVIGATION_CASE_TYPE__TO_VIEW_ID = 6;
-
-				/**
-	 * The feature id for the '<em><b>Redirect</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAVIGATION_CASE_TYPE__REDIRECT = 7;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAVIGATION_CASE_TYPE__ID = 8;
-
-				/**
-	 * The number of structural features of the '<em>Navigation Case Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAVIGATION_CASE_TYPE_FEATURE_COUNT = 9;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAVIGATION_HANDLER_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAVIGATION_HANDLER_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Navigation Handler Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAVIGATION_HANDLER_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Description</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAVIGATION_RULE_TYPE__DESCRIPTION = 0;
-
-				/**
-	 * The feature id for the '<em><b>Display Name</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAVIGATION_RULE_TYPE__DISPLAY_NAME = 1;
-
-				/**
-	 * The feature id for the '<em><b>Icon</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAVIGATION_RULE_TYPE__ICON = 2;
-
-				/**
-	 * The feature id for the '<em><b>From View Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAVIGATION_RULE_TYPE__FROM_VIEW_ID = 3;
-
-				/**
-	 * The feature id for the '<em><b>Navigation Case</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAVIGATION_RULE_TYPE__NAVIGATION_CASE = 4;
-
-				/**
-	 * The feature id for the '<em><b>Navigation Rule Extension</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int NAVIGATION_RULE_TYPE__NAVIGATION_RULE_EXTENSION = 5;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAVIGATION_RULE_TYPE__ID = 6;
-
-				/**
-	 * The number of structural features of the '<em>Navigation Rule Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NAVIGATION_RULE_TYPE_FEATURE_COUNT = 7;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationRuleExtensionTypeImpl <em>Navigation Rule Extension Type</em>}' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationRuleExtensionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getNavigationRuleExtensionType()
-	 * @generated
-	 */
-    int NAVIGATION_RULE_EXTENSION_TYPE = 73;
-
-    /**
-	 * The feature id for the '<em><b>Child Nodes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int NAVIGATION_RULE_EXTENSION_TYPE__CHILD_NODES = EXTENSION_TYPE__CHILD_NODES;
-
-    /**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int NAVIGATION_RULE_EXTENSION_TYPE__TEXT_CONTENT = EXTENSION_TYPE__TEXT_CONTENT;
-
-    /**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int NAVIGATION_RULE_EXTENSION_TYPE__ID = EXTENSION_TYPE__ID;
-
-    /**
-	 * The number of structural features of the '<em>Navigation Rule Extension Type</em>' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int NAVIGATION_RULE_EXTENSION_TYPE_FEATURE_COUNT = EXTENSION_TYPE_FEATURE_COUNT + 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NULL_VALUE_TYPE__ID = 0;
-
-				/**
-	 * The number of structural features of the '<em>Null Value Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int NULL_VALUE_TYPE_FEATURE_COUNT = 1;
-
-				/**
-	 * The feature id for the '<em><b>Before</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ORDERING_TYPE__BEFORE = 0;
-
-				/**
-	 * The feature id for the '<em><b>After</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ORDERING_TYPE__AFTER = 1;
-
-				/**
-	 * The number of structural features of the '<em>Ordering Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ORDERING_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Name</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ORDERING_ORDERING_TYPE__NAME = 0;
-
-				/**
-	 * The feature id for the '<em><b>Others</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ORDERING_ORDERING_TYPE__OTHERS = 1;
-
-				/**
-	 * The number of structural features of the '<em>Ordering Ordering Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ORDERING_ORDERING_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ORDERING_OTHERS_TYPE__ID = 0;
-
-				/**
-	 * The number of structural features of the '<em>Ordering Others Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int ORDERING_OTHERS_TYPE_FEATURE_COUNT = 1;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARTIAL_VIEW_CONTEXT_FACTORY_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARTIAL_VIEW_CONTEXT_FACTORY_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Partial View Context Factory Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PARTIAL_VIEW_CONTEXT_FACTORY_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PHASE_LISTENER_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PHASE_LISTENER_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Phase Listener Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PHASE_LISTENER_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_CLASS_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_CLASS_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Property Class Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_CLASS_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Child Nodes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int PROPERTY_EXTENSION_TYPE__CHILD_NODES = EXTENSION_TYPE__CHILD_NODES;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int PROPERTY_EXTENSION_TYPE__TEXT_CONTENT = EXTENSION_TYPE__TEXT_CONTENT;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_EXTENSION_TYPE__ID = EXTENSION_TYPE__ID;
-
-				/**
-	 * The number of structural features of the '<em>Property Extension Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_EXTENSION_TYPE_FEATURE_COUNT = EXTENSION_TYPE_FEATURE_COUNT + 0;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_NAME_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_NAME_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Property Name Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_NAME_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_RESOLVER_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_RESOLVER_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Property Resolver Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_RESOLVER_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Description</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_TYPE__DESCRIPTION = 0;
-
-				/**
-	 * The feature id for the '<em><b>Display Name</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_TYPE__DISPLAY_NAME = 1;
-
-				/**
-	 * The feature id for the '<em><b>Icon</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_TYPE__ICON = 2;
-
-				/**
-	 * The feature id for the '<em><b>Property Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_TYPE__PROPERTY_NAME = 3;
-
-				/**
-	 * The feature id for the '<em><b>Property Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_TYPE__PROPERTY_CLASS = 4;
-
-				/**
-	 * The feature id for the '<em><b>Default Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_TYPE__DEFAULT_VALUE = 5;
-
-				/**
-	 * The feature id for the '<em><b>Suggested Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_TYPE__SUGGESTED_VALUE = 6;
-
-				/**
-	 * The feature id for the '<em><b>Property Extension</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_TYPE__PROPERTY_EXTENSION = 7;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_TYPE__ID = 8;
-
-				/**
-	 * The number of structural features of the '<em>Property Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROPERTY_TYPE_FEATURE_COUNT = 9;
-
-				/**
-	 * The feature id for the '<em><b>View Param</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REDIRECT_TYPE__VIEW_PARAM = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REDIRECT_TYPE__ID = 1;
-
-				/**
-	 * The feature id for the '<em><b>Include View Params</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REDIRECT_TYPE__INCLUDE_VIEW_PARAMS = 2;
-
-				/**
-	 * The number of structural features of the '<em>Redirect Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REDIRECT_TYPE_FEATURE_COUNT = 3;
-
-				/**
-	 * The feature id for the '<em><b>Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REDIRECT_VIEW_PARAM_TYPE__NAME = 0;
-
-				/**
-	 * The feature id for the '<em><b>Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REDIRECT_VIEW_PARAM_TYPE__VALUE = 1;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REDIRECT_VIEW_PARAM_TYPE__ID = 2;
-
-				/**
-	 * The number of structural features of the '<em>Redirect View Param Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REDIRECT_VIEW_PARAM_TYPE_FEATURE_COUNT = 3;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REFERENCED_BEAN_CLASS_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REFERENCED_BEAN_CLASS_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Referenced Bean Class Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REFERENCED_BEAN_CLASS_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REFERENCED_BEAN_NAME_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REFERENCED_BEAN_NAME_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Referenced Bean Name Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REFERENCED_BEAN_NAME_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Description</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REFERENCED_BEAN_TYPE__DESCRIPTION = 0;
-
-				/**
-	 * The feature id for the '<em><b>Display Name</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REFERENCED_BEAN_TYPE__DISPLAY_NAME = 1;
-
-				/**
-	 * The feature id for the '<em><b>Icon</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REFERENCED_BEAN_TYPE__ICON = 2;
-
-				/**
-	 * The feature id for the '<em><b>Referenced Bean Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REFERENCED_BEAN_TYPE__REFERENCED_BEAN_NAME = 3;
-
-				/**
-	 * The feature id for the '<em><b>Referenced Bean Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REFERENCED_BEAN_TYPE__REFERENCED_BEAN_CLASS = 4;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REFERENCED_BEAN_TYPE__ID = 5;
-
-				/**
-	 * The number of structural features of the '<em>Referenced Bean Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int REFERENCED_BEAN_TYPE_FEATURE_COUNT = 6;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDERER_CLASS_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDERER_CLASS_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Renderer Class Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDERER_CLASS_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Child Nodes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int RENDERER_EXTENSION_TYPE__CHILD_NODES = EXTENSION_TYPE__CHILD_NODES;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int RENDERER_EXTENSION_TYPE__TEXT_CONTENT = EXTENSION_TYPE__TEXT_CONTENT;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDERER_EXTENSION_TYPE__ID = EXTENSION_TYPE__ID;
-
-				/**
-	 * The number of structural features of the '<em>Renderer Extension Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDERER_EXTENSION_TYPE_FEATURE_COUNT = EXTENSION_TYPE_FEATURE_COUNT + 0;
-
-				/**
-	 * The feature id for the '<em><b>Description</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDERER_TYPE__DESCRIPTION = 0;
-
-				/**
-	 * The feature id for the '<em><b>Display Name</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDERER_TYPE__DISPLAY_NAME = 1;
-
-				/**
-	 * The feature id for the '<em><b>Icon</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDERER_TYPE__ICON = 2;
-
-				/**
-	 * The feature id for the '<em><b>Component Family</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDERER_TYPE__COMPONENT_FAMILY = 3;
-
-				/**
-	 * The feature id for the '<em><b>Renderer Type</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDERER_TYPE__RENDERER_TYPE = 4;
-
-				/**
-	 * The feature id for the '<em><b>Renderer Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDERER_TYPE__RENDERER_CLASS = 5;
-
-				/**
-	 * The feature id for the '<em><b>Facet</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDERER_TYPE__FACET = 6;
-
-				/**
-	 * The feature id for the '<em><b>Attribute</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDERER_TYPE__ATTRIBUTE = 7;
-
-				/**
-	 * The feature id for the '<em><b>Renderer Extension</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDERER_TYPE__RENDERER_EXTENSION = 8;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDERER_TYPE__ID = 9;
-
-				/**
-	 * The number of structural features of the '<em>Renderer Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDERER_TYPE_FEATURE_COUNT = 10;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDERER_TYPE_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDERER_TYPE_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Renderer Type Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDERER_TYPE_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDER_KIT_CLASS_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDER_KIT_CLASS_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Render Kit Class Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDER_KIT_CLASS_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDER_KIT_FACTORY_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDER_KIT_FACTORY_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Render Kit Factory Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDER_KIT_FACTORY_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDER_KIT_ID_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDER_KIT_ID_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Render Kit Id Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDER_KIT_ID_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Description</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDER_KIT_TYPE__DESCRIPTION = 0;
-
-				/**
-	 * The feature id for the '<em><b>Display Name</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDER_KIT_TYPE__DISPLAY_NAME = 1;
-
-				/**
-	 * The feature id for the '<em><b>Icon</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDER_KIT_TYPE__ICON = 2;
-
-				/**
-	 * The feature id for the '<em><b>Render Kit Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDER_KIT_TYPE__RENDER_KIT_ID = 3;
-
-				/**
-	 * The feature id for the '<em><b>Render Kit Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDER_KIT_TYPE__RENDER_KIT_CLASS = 4;
-
-				/**
-	 * The feature id for the '<em><b>Renderer</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDER_KIT_TYPE__RENDERER = 5;
-
-				/**
-	 * The feature id for the '<em><b>Client Behavior Renderer</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDER_KIT_TYPE__CLIENT_BEHAVIOR_RENDERER = 6;
-
-				/**
-	 * The feature id for the '<em><b>Render Kit Extension</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int RENDER_KIT_TYPE__RENDER_KIT_EXTENSION = 7;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDER_KIT_TYPE__ID = 8;
-
-				/**
-	 * The number of structural features of the '<em>Render Kit Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RENDER_KIT_TYPE_FEATURE_COUNT = 9;
-
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorExtensionTypeImpl <em>Validator Extension Type</em>}' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorExtensionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getValidatorExtensionType()
-	 * @generated
-	 */
-    int VALIDATOR_EXTENSION_TYPE = 113;
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ViewDeclarationLanguageFactoryTypeImpl <em>View Declaration Language Factory Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ViewDeclarationLanguageFactoryTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getViewDeclarationLanguageFactoryType()
-	 * @generated
-	 */
-	int VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE = 121;
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.VisitContextFactoryTypeImpl <em>Visit Context Factory Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.VisitContextFactoryTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getVisitContextFactoryType()
-	 * @generated
-	 */
-	int VISIT_CONTEXT_FACTORY_TYPE = 122;
-
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.AbsoluteOrderingType <em>Absolute Ordering Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Absolute Ordering Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.AbsoluteOrderingType
-	 * @generated
-	 */
-	EClass getAbsoluteOrderingType();
-
-				/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.AbsoluteOrderingType#getName <em>Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.AbsoluteOrderingType#getName()
-	 * @see #getAbsoluteOrderingType()
-	 * @generated
-	 */
-	EReference getAbsoluteOrderingType_Name();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.AbsoluteOrderingType#getOthers <em>Others</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Others</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.AbsoluteOrderingType#getOthers()
-	 * @see #getAbsoluteOrderingType()
-	 * @generated
-	 */
-	EReference getAbsoluteOrderingType_Others();
-
-				/**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitExtensionTypeImpl <em>Render Kit Extension Type</em>}' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitExtensionTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRenderKitExtensionType()
-	 * @generated
-	 */
-    int RENDER_KIT_EXTENSION_TYPE = 98;
-
-    /**
-	 * The feature id for the '<em><b>Child Nodes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int RENDER_KIT_EXTENSION_TYPE__CHILD_NODES = EXTENSION_TYPE__CHILD_NODES;
-
-    /**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int RENDER_KIT_EXTENSION_TYPE__TEXT_CONTENT = EXTENSION_TYPE__TEXT_CONTENT;
-
-    /**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int RENDER_KIT_EXTENSION_TYPE__ID = EXTENSION_TYPE__ID;
-
-    /**
-	 * The number of structural features of the '<em>Render Kit Extension Type</em>' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int RENDER_KIT_EXTENSION_TYPE_FEATURE_COUNT = EXTENSION_TYPE_FEATURE_COUNT + 0;
-
-
-    /**
-	 * The meta object id for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ResourceHandlerTypeImpl <em>Resource Handler Type</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ResourceHandlerTypeImpl
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getResourceHandlerType()
-	 * @generated
-	 */
-	int RESOURCE_HANDLER_TYPE = 99;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RESOURCE_HANDLER_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RESOURCE_HANDLER_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Resource Handler Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int RESOURCE_HANDLER_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SMALL_ICON_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SMALL_ICON_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Small Icon Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SMALL_ICON_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SOURCE_CLASS_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SOURCE_CLASS_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Source Class Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SOURCE_CLASS_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int STATE_MANAGER_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int STATE_MANAGER_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>State Manager Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int STATE_MANAGER_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SUGGESTED_VALUE_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SUGGESTED_VALUE_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Suggested Value Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SUGGESTED_VALUE_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SUPPORTED_LOCALE_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SUPPORTED_LOCALE_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Supported Locale Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SUPPORTED_LOCALE_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SYSTEM_EVENT_CLASS_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SYSTEM_EVENT_CLASS_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>System Event Class Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SYSTEM_EVENT_CLASS_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SYSTEM_EVENT_LISTENER_CLASS_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SYSTEM_EVENT_LISTENER_CLASS_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>System Event Listener Class Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SYSTEM_EVENT_LISTENER_CLASS_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>System Event Listener Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_LISTENER_CLASS = 0;
-
-				/**
-	 * The feature id for the '<em><b>System Event Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_CLASS = 1;
-
-				/**
-	 * The feature id for the '<em><b>Source Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SYSTEM_EVENT_LISTENER_TYPE__SOURCE_CLASS = 2;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SYSTEM_EVENT_LISTENER_TYPE__ID = 3;
-
-				/**
-	 * The number of structural features of the '<em>System Event Listener Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int SYSTEM_EVENT_LISTENER_TYPE_FEATURE_COUNT = 4;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TAG_HANDLER_DELEGATE_FACTORY_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TAG_HANDLER_DELEGATE_FACTORY_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Tag Handler Delegate Factory Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TAG_HANDLER_DELEGATE_FACTORY_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TO_VIEW_ID_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TO_VIEW_ID_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>To View Id Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int TO_VIEW_ID_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VALIDATOR_CLASS_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VALIDATOR_CLASS_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Validator Class Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VALIDATOR_CLASS_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VALIDATOR_ID_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VALIDATOR_ID_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Validator Id Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VALIDATOR_ID_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Description</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VALIDATOR_TYPE__DESCRIPTION = 0;
-
-				/**
-	 * The feature id for the '<em><b>Display Name</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VALIDATOR_TYPE__DISPLAY_NAME = 1;
-
-				/**
-	 * The feature id for the '<em><b>Icon</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VALIDATOR_TYPE__ICON = 2;
-
-				/**
-	 * The feature id for the '<em><b>Validator Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VALIDATOR_TYPE__VALIDATOR_ID = 3;
-
-				/**
-	 * The feature id for the '<em><b>Validator Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VALIDATOR_TYPE__VALIDATOR_CLASS = 4;
-
-				/**
-	 * The feature id for the '<em><b>Attribute</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VALIDATOR_TYPE__ATTRIBUTE = 5;
-
-				/**
-	 * The feature id for the '<em><b>Property</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VALIDATOR_TYPE__PROPERTY = 6;
-
-				/**
-	 * The feature id for the '<em><b>Validator Extension</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int VALIDATOR_TYPE__VALIDATOR_EXTENSION = 7;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VALIDATOR_TYPE__ID = 8;
-
-				/**
-	 * The number of structural features of the '<em>Validator Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VALIDATOR_TYPE_FEATURE_COUNT = 9;
-
-				/**
-	 * The feature id for the '<em><b>Child Nodes</b></em>' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int VALIDATOR_EXTENSION_TYPE__CHILD_NODES = EXTENSION_TYPE__CHILD_NODES;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int VALIDATOR_EXTENSION_TYPE__TEXT_CONTENT = EXTENSION_TYPE__TEXT_CONTENT;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int VALIDATOR_EXTENSION_TYPE__ID = EXTENSION_TYPE__ID;
-
-				/**
-	 * The number of structural features of the '<em>Validator Extension Type</em>' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int VALIDATOR_EXTENSION_TYPE_FEATURE_COUNT = EXTENSION_TYPE_FEATURE_COUNT + 0;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VALUE_CLASS_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VALUE_CLASS_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Value Class Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VALUE_CLASS_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VALUE_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VALUE_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Value Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VALUE_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VARIABLE_RESOLVER_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VARIABLE_RESOLVER_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Variable Resolver Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VARIABLE_RESOLVER_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VIEW_HANDLER_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VIEW_HANDLER_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>View Handler Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VIEW_HANDLER_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Description</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int RESOURCE_BUNDLE_TYPE__DESCRIPTION = 0;
-
-				/**
-	 * The feature id for the '<em><b>Display Name</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int RESOURCE_BUNDLE_TYPE__DISPLAY_NAME = 1;
-
-				/**
-	 * The feature id for the '<em><b>Icon</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int RESOURCE_BUNDLE_TYPE__ICON = 2;
-
-				/**
-	 * The feature id for the '<em><b>Base Name</b></em>' reference.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int RESOURCE_BUNDLE_TYPE__BASE_NAME = 3;
-
-				/**
-	 * The feature id for the '<em><b>Var</b></em>' reference.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int RESOURCE_BUNDLE_TYPE__VAR = 4;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int RESOURCE_BUNDLE_TYPE__ID = 5;
-
-				/**
-	 * The number of structural features of the '<em>Resource Bundle Type</em>' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int RESOURCE_BUNDLE_TYPE_FEATURE_COUNT = 6;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int BASE_NAME_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int BASE_NAME_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Base Name Type</em>' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int BASE_NAME_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int VAR_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int VAR_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Var Type</em>' class.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-    int VAR_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>View Declaration Language Factory Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE_FEATURE_COUNT = 2;
-
-				/**
-	 * The feature id for the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VISIT_CONTEXT_FACTORY_TYPE__TEXT_CONTENT = 0;
-
-				/**
-	 * The feature id for the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VISIT_CONTEXT_FACTORY_TYPE__ID = 1;
-
-				/**
-	 * The number of structural features of the '<em>Visit Context Factory Type</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int VISIT_CONTEXT_FACTORY_TYPE_FEATURE_COUNT = 2;
-
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ActionListenerType <em>Action Listener Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Action Listener Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ActionListenerType
-	 * @generated
-	 */
-	EClass getActionListenerType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ActionListenerType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ActionListenerType#getTextContent()
-	 * @see #getActionListenerType()
-	 * @generated
-	 */
-	EAttribute getActionListenerType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ActionListenerType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ActionListenerType#getId()
-	 * @see #getActionListenerType()
-	 * @generated
-	 */
-	EAttribute getActionListenerType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationFactoryType <em>Application Factory Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Application Factory Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ApplicationFactoryType
-	 * @generated
-	 */
-	EClass getApplicationFactoryType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationFactoryType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ApplicationFactoryType#getTextContent()
-	 * @see #getApplicationFactoryType()
-	 * @generated
-	 */
-	EAttribute getApplicationFactoryType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationFactoryType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ApplicationFactoryType#getId()
-	 * @see #getApplicationFactoryType()
-	 * @generated
-	 */
-	EAttribute getApplicationFactoryType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType <em>Application Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Application Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ApplicationType
-	 * @generated
-	 */
-	EClass getApplicationType();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getActionListener <em>Action Listener</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Action Listener</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getActionListener()
-	 * @see #getApplicationType()
-	 * @generated
-	 */
-	EReference getApplicationType_ActionListener();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getDefaultRenderKitId <em>Default Render Kit Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Default Render Kit Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getDefaultRenderKitId()
-	 * @see #getApplicationType()
-	 * @generated
-	 */
-	EReference getApplicationType_DefaultRenderKitId();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getMessageBundle <em>Message Bundle</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Message Bundle</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getMessageBundle()
-	 * @see #getApplicationType()
-	 * @generated
-	 */
-	EReference getApplicationType_MessageBundle();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getNavigationHandler <em>Navigation Handler</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Navigation Handler</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getNavigationHandler()
-	 * @see #getApplicationType()
-	 * @generated
-	 */
-	EReference getApplicationType_NavigationHandler();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getViewHandler <em>View Handler</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>View Handler</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getViewHandler()
-	 * @see #getApplicationType()
-	 * @generated
-	 */
-	EReference getApplicationType_ViewHandler();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getStateManager <em>State Manager</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>State Manager</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getStateManager()
-	 * @see #getApplicationType()
-	 * @generated
-	 */
-	EReference getApplicationType_StateManager();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getPropertyResolver <em>Property Resolver</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Property Resolver</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getPropertyResolver()
-	 * @see #getApplicationType()
-	 * @generated
-	 */
-	EReference getApplicationType_PropertyResolver();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getVariableResolver <em>Variable Resolver</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Variable Resolver</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getVariableResolver()
-	 * @see #getApplicationType()
-	 * @generated
-	 */
-	EReference getApplicationType_VariableResolver();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getResourceHandler <em>Resource Handler</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Resource Handler</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getResourceHandler()
-	 * @see #getApplicationType()
-	 * @generated
-	 */
-	EReference getApplicationType_ResourceHandler();
-
-				/**
-	 * Returns the meta object for the reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getSystemEventListener <em>System Event Listener</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference list '<em>System Event Listener</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getSystemEventListener()
-	 * @see #getApplicationType()
-	 * @generated
-	 */
-	EReference getApplicationType_SystemEventListener();
-
-				/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getLocaleConfig <em>Locale Config</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Locale Config</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getLocaleConfig()
-	 * @see #getApplicationType()
-	 * @generated
-	 */
-	EReference getApplicationType_LocaleConfig();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getId()
-	 * @see #getApplicationType()
-	 * @generated
-	 */
-	EAttribute getApplicationType_Id();
-
-    /**
-	 * Returns the meta object for the reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getELResolver <em>EL Resolver</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the reference list '<em>EL Resolver</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getELResolver()
-	 * @see #getApplicationType()
-	 * @generated
-	 */
-    EReference getApplicationType_ELResolver();
-
-    /**
-	 * Returns the meta object for the reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getResourceBundle <em>Resource Bundle</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the reference list '<em>Resource Bundle</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getResourceBundle()
-	 * @see #getApplicationType()
-	 * @generated
-	 */
-    EReference getApplicationType_ResourceBundle();
-
-    /**
-	 * Returns the meta object for the reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getApplicationExtension <em>Application Extension</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the reference list '<em>Application Extension</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getApplicationExtension()
-	 * @see #getApplicationType()
-	 * @generated
-	 */
-    EReference getApplicationType_ApplicationExtension();
-
-    /**
-	 * Returns the meta object for the reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getDefaultValidators <em>Default Validators</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference list '<em>Default Validators</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ApplicationType#getDefaultValidators()
-	 * @see #getApplicationType()
-	 * @generated
-	 */
-	EReference getApplicationType_DefaultValidators();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeClassType <em>Attribute Class Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Attribute Class Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.AttributeClassType
-	 * @generated
-	 */
-	EClass getAttributeClassType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeClassType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.AttributeClassType#getTextContent()
-	 * @see #getAttributeClassType()
-	 * @generated
-	 */
-	EAttribute getAttributeClassType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeClassType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.AttributeClassType#getId()
-	 * @see #getAttributeClassType()
-	 * @generated
-	 */
-	EAttribute getAttributeClassType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeExtensionType <em>Attribute Extension Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Attribute Extension Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.AttributeExtensionType
-	 * @generated
-	 */
-	EClass getAttributeExtensionType();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeNameType <em>Attribute Name Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Attribute Name Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.AttributeNameType
-	 * @generated
-	 */
-	EClass getAttributeNameType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeNameType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.AttributeNameType#getTextContent()
-	 * @see #getAttributeNameType()
-	 * @generated
-	 */
-	EAttribute getAttributeNameType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeNameType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.AttributeNameType#getId()
-	 * @see #getAttributeNameType()
-	 * @generated
-	 */
-	EAttribute getAttributeNameType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType <em>Attribute Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Attribute Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.AttributeType
-	 * @generated
-	 */
-	EClass getAttributeType();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getDescription <em>Description</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Description</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getDescription()
-	 * @see #getAttributeType()
-	 * @generated
-	 */
-	EReference getAttributeType_Description();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getDisplayName <em>Display Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Display Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getDisplayName()
-	 * @see #getAttributeType()
-	 * @generated
-	 */
-	EReference getAttributeType_DisplayName();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getIcon <em>Icon</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Icon</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getIcon()
-	 * @see #getAttributeType()
-	 * @generated
-	 */
-	EReference getAttributeType_Icon();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getAttributeName <em>Attribute Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Attribute Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getAttributeName()
-	 * @see #getAttributeType()
-	 * @generated
-	 */
-	EReference getAttributeType_AttributeName();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getAttributeClass <em>Attribute Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Attribute Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getAttributeClass()
-	 * @see #getAttributeType()
-	 * @generated
-	 */
-	EReference getAttributeType_AttributeClass();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getDefaultValue <em>Default Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Default Value</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getDefaultValue()
-	 * @see #getAttributeType()
-	 * @generated
-	 */
-	EReference getAttributeType_DefaultValue();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getSuggestedValue <em>Suggested Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Suggested Value</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getSuggestedValue()
-	 * @see #getAttributeType()
-	 * @generated
-	 */
-	EReference getAttributeType_SuggestedValue();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getAttributeExtension <em>Attribute Extension</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Attribute Extension</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getAttributeExtension()
-	 * @see #getAttributeType()
-	 * @generated
-	 */
-	EReference getAttributeType_AttributeExtension();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.AttributeType#getId()
-	 * @see #getAttributeType()
-	 * @generated
-	 */
-	EAttribute getAttributeType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorClassType <em>Behavior Class Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Behavior Class Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.BehaviorClassType
-	 * @generated
-	 */
-	EClass getBehaviorClassType();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorClassType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.BehaviorClassType#getTextContent()
-	 * @see #getBehaviorClassType()
-	 * @generated
-	 */
-	EAttribute getBehaviorClassType_TextContent();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorClassType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.BehaviorClassType#getId()
-	 * @see #getBehaviorClassType()
-	 * @generated
-	 */
-	EAttribute getBehaviorClassType_Id();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorIdType <em>Behavior Id Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Behavior Id Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.BehaviorIdType
-	 * @generated
-	 */
-	EClass getBehaviorIdType();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorIdType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.BehaviorIdType#getTextContent()
-	 * @see #getBehaviorIdType()
-	 * @generated
-	 */
-	EAttribute getBehaviorIdType_TextContent();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorIdType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.BehaviorIdType#getId()
-	 * @see #getBehaviorIdType()
-	 * @generated
-	 */
-	EAttribute getBehaviorIdType_Id();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType <em>Behavior Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Behavior Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.BehaviorType
-	 * @generated
-	 */
-	EClass getBehaviorType();
-
-				/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getDescription <em>Description</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Description</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getDescription()
-	 * @see #getBehaviorType()
-	 * @generated
-	 */
-	EReference getBehaviorType_Description();
-
-				/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getDisplayName <em>Display Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Display Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getDisplayName()
-	 * @see #getBehaviorType()
-	 * @generated
-	 */
-	EReference getBehaviorType_DisplayName();
-
-				/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getIcon <em>Icon</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Icon</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getIcon()
-	 * @see #getBehaviorType()
-	 * @generated
-	 */
-	EReference getBehaviorType_Icon();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getBehaviorId <em>Behavior Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Behavior Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getBehaviorId()
-	 * @see #getBehaviorType()
-	 * @generated
-	 */
-	EReference getBehaviorType_BehaviorId();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getBehaviorClass <em>Behavior Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Behavior Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getBehaviorClass()
-	 * @see #getBehaviorType()
-	 * @generated
-	 */
-	EReference getBehaviorType_BehaviorClass();
-
-				/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getAttribute <em>Attribute</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Attribute</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getAttribute()
-	 * @see #getBehaviorType()
-	 * @generated
-	 */
-	EReference getBehaviorType_Attribute();
-
-				/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getProperty <em>Property</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Property</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getProperty()
-	 * @see #getBehaviorType()
-	 * @generated
-	 */
-	EReference getBehaviorType_Property();
-
-				/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getBehaviorExtension <em>Behavior Extension</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Behavior Extension</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.BehaviorType#getBehaviorExtension()
-	 * @see #getBehaviorType()
-	 * @generated
-	 */
-	EReference getBehaviorType_BehaviorExtension();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorExtensionType <em>Behavior Extension Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Behavior Extension Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.BehaviorExtensionType
-	 * @generated
-	 */
-	EClass getBehaviorExtensionType();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererClassType <em>Client Behavior Renderer Class Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Client Behavior Renderer Class Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererClassType
-	 * @generated
-	 */
-	EClass getClientBehaviorRendererClassType();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererClassType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererClassType#getTextContent()
-	 * @see #getClientBehaviorRendererClassType()
-	 * @generated
-	 */
-	EAttribute getClientBehaviorRendererClassType_TextContent();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererClassType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererClassType#getId()
-	 * @see #getClientBehaviorRendererClassType()
-	 * @generated
-	 */
-	EAttribute getClientBehaviorRendererClassType_Id();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererType <em>Client Behavior Renderer Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Client Behavior Renderer Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererType
-	 * @generated
-	 */
-	EClass getClientBehaviorRendererType();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererType#getClientBehaviorRendererType <em>Client Behavior Renderer Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Client Behavior Renderer Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererType#getClientBehaviorRendererType()
-	 * @see #getClientBehaviorRendererType()
-	 * @generated
-	 */
-	EReference getClientBehaviorRendererType_ClientBehaviorRendererType();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererType#getClientBehaviorRendererClass <em>Client Behavior Renderer Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Client Behavior Renderer Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererType#getClientBehaviorRendererClass()
-	 * @see #getClientBehaviorRendererType()
-	 * @generated
-	 */
-	EReference getClientBehaviorRendererType_ClientBehaviorRendererClass();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererTypeType <em>Client Behavior Renderer Type Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Client Behavior Renderer Type Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererTypeType
-	 * @generated
-	 */
-	EClass getClientBehaviorRendererTypeType();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererTypeType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererTypeType#getTextContent()
-	 * @see #getClientBehaviorRendererTypeType()
-	 * @generated
-	 */
-	EAttribute getClientBehaviorRendererTypeType_TextContent();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererTypeType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererTypeType#getId()
-	 * @see #getClientBehaviorRendererTypeType()
-	 * @generated
-	 */
-	EAttribute getClientBehaviorRendererTypeType_Id();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentClassType <em>Component Class Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Component Class Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ComponentClassType
-	 * @generated
-	 */
-	EClass getComponentClassType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentClassType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ComponentClassType#getTextContent()
-	 * @see #getComponentClassType()
-	 * @generated
-	 */
-	EAttribute getComponentClassType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentClassType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ComponentClassType#getId()
-	 * @see #getComponentClassType()
-	 * @generated
-	 */
-	EAttribute getComponentClassType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentExtensionType <em>Component Extension Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Component Extension Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ComponentExtensionType
-	 * @generated
-	 */
-	EClass getComponentExtensionType();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentFamilyType <em>Component Family Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Component Family Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ComponentFamilyType
-	 * @generated
-	 */
-	EClass getComponentFamilyType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentFamilyType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ComponentFamilyType#getTextContent()
-	 * @see #getComponentFamilyType()
-	 * @generated
-	 */
-	EAttribute getComponentFamilyType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentFamilyType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ComponentFamilyType#getId()
-	 * @see #getComponentFamilyType()
-	 * @generated
-	 */
-	EAttribute getComponentFamilyType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType <em>Component Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Component Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ComponentType
-	 * @generated
-	 */
-	EClass getComponentType();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getDescription <em>Description</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Description</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getDescription()
-	 * @see #getComponentType()
-	 * @generated
-	 */
-	EReference getComponentType_Description();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getDisplayName <em>Display Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Display Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getDisplayName()
-	 * @see #getComponentType()
-	 * @generated
-	 */
-	EReference getComponentType_DisplayName();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getIcon <em>Icon</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Icon</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getIcon()
-	 * @see #getComponentType()
-	 * @generated
-	 */
-	EReference getComponentType_Icon();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getComponentType <em>Component Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Component Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getComponentType()
-	 * @see #getComponentType()
-	 * @generated
-	 */
-	EReference getComponentType_ComponentType();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getComponentClass <em>Component Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Component Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getComponentClass()
-	 * @see #getComponentType()
-	 * @generated
-	 */
-	EReference getComponentType_ComponentClass();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getFacet <em>Facet</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Facet</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getFacet()
-	 * @see #getComponentType()
-	 * @generated
-	 */
-	EReference getComponentType_Facet();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getAttribute <em>Attribute</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Attribute</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getAttribute()
-	 * @see #getComponentType()
-	 * @generated
-	 */
-	EReference getComponentType_Attribute();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getProperty <em>Property</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Property</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getProperty()
-	 * @see #getComponentType()
-	 * @generated
-	 */
-	EReference getComponentType_Property();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getComponentExtension <em>Component Extension</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Component Extension</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getComponentExtension()
-	 * @see #getComponentType()
-	 * @generated
-	 */
-	EReference getComponentType_ComponentExtension();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ComponentType#getId()
-	 * @see #getComponentType()
-	 * @generated
-	 */
-	EAttribute getComponentType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentTypeType <em>Component Type Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Component Type Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ComponentTypeType
-	 * @generated
-	 */
-	EClass getComponentTypeType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentTypeType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ComponentTypeType#getTextContent()
-	 * @see #getComponentTypeType()
-	 * @generated
-	 */
-	EAttribute getComponentTypeType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentTypeType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ComponentTypeType#getId()
-	 * @see #getComponentTypeType()
-	 * @generated
-	 */
-	EAttribute getComponentTypeType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterClassType <em>Converter Class Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Converter Class Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ConverterClassType
-	 * @generated
-	 */
-	EClass getConverterClassType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterClassType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ConverterClassType#getTextContent()
-	 * @see #getConverterClassType()
-	 * @generated
-	 */
-	EAttribute getConverterClassType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterClassType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ConverterClassType#getId()
-	 * @see #getConverterClassType()
-	 * @generated
-	 */
-	EAttribute getConverterClassType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterForClassType <em>Converter For Class Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Converter For Class Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ConverterForClassType
-	 * @generated
-	 */
-	EClass getConverterForClassType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterForClassType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ConverterForClassType#getTextContent()
-	 * @see #getConverterForClassType()
-	 * @generated
-	 */
-	EAttribute getConverterForClassType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterForClassType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ConverterForClassType#getId()
-	 * @see #getConverterForClassType()
-	 * @generated
-	 */
-	EAttribute getConverterForClassType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterIdType <em>Converter Id Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Converter Id Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ConverterIdType
-	 * @generated
-	 */
-	EClass getConverterIdType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterIdType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ConverterIdType#getTextContent()
-	 * @see #getConverterIdType()
-	 * @generated
-	 */
-	EAttribute getConverterIdType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterIdType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ConverterIdType#getId()
-	 * @see #getConverterIdType()
-	 * @generated
-	 */
-	EAttribute getConverterIdType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType <em>Converter Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Converter Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ConverterType
-	 * @generated
-	 */
-	EClass getConverterType();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getDescription <em>Description</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Description</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getDescription()
-	 * @see #getConverterType()
-	 * @generated
-	 */
-	EReference getConverterType_Description();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getDisplayName <em>Display Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Display Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getDisplayName()
-	 * @see #getConverterType()
-	 * @generated
-	 */
-	EReference getConverterType_DisplayName();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getIcon <em>Icon</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Icon</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getIcon()
-	 * @see #getConverterType()
-	 * @generated
-	 */
-	EReference getConverterType_Icon();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getConverterId <em>Converter Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Converter Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getConverterId()
-	 * @see #getConverterType()
-	 * @generated
-	 */
-	EReference getConverterType_ConverterId();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getConverterForClass <em>Converter For Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Converter For Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getConverterForClass()
-	 * @see #getConverterType()
-	 * @generated
-	 */
-	EReference getConverterType_ConverterForClass();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getConverterClass <em>Converter Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Converter Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getConverterClass()
-	 * @see #getConverterType()
-	 * @generated
-	 */
-	EReference getConverterType_ConverterClass();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getAttribute <em>Attribute</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Attribute</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getAttribute()
-	 * @see #getConverterType()
-	 * @generated
-	 */
-	EReference getConverterType_Attribute();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getProperty <em>Property</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Property</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getProperty()
-	 * @see #getConverterType()
-	 * @generated
-	 */
-	EReference getConverterType_Property();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getConverterExtension <em>Converter Extension</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Converter Extension</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getConverterExtension()
-	 * @see #getConverterType()
-	 * @generated
-	 */
-    EReference getConverterType_ConverterExtension();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ConverterType#getId()
-	 * @see #getConverterType()
-	 * @generated
-	 */
-	EAttribute getConverterType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultLocaleType <em>Default Locale Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Default Locale Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DefaultLocaleType
-	 * @generated
-	 */
-	EClass getDefaultLocaleType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultLocaleType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DefaultLocaleType#getTextContent()
-	 * @see #getDefaultLocaleType()
-	 * @generated
-	 */
-	EAttribute getDefaultLocaleType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultLocaleType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DefaultLocaleType#getId()
-	 * @see #getDefaultLocaleType()
-	 * @generated
-	 */
-	EAttribute getDefaultLocaleType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultRenderKitIdType <em>Default Render Kit Id Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Default Render Kit Id Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DefaultRenderKitIdType
-	 * @generated
-	 */
-	EClass getDefaultRenderKitIdType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultRenderKitIdType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DefaultRenderKitIdType#getTextContent()
-	 * @see #getDefaultRenderKitIdType()
-	 * @generated
-	 */
-	EAttribute getDefaultRenderKitIdType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultRenderKitIdType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DefaultRenderKitIdType#getId()
-	 * @see #getDefaultRenderKitIdType()
-	 * @generated
-	 */
-	EAttribute getDefaultRenderKitIdType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValidatorsType <em>Default Validators Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Default Validators Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DefaultValidatorsType
-	 * @generated
-	 */
-	EClass getDefaultValidatorsType();
-
-				/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValidatorsType#getValidatorId <em>Validator Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Validator Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DefaultValidatorsType#getValidatorId()
-	 * @see #getDefaultValidatorsType()
-	 * @generated
-	 */
-	EReference getDefaultValidatorsType_ValidatorId();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValidatorsType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DefaultValidatorsType#getId()
-	 * @see #getDefaultValidatorsType()
-	 * @generated
-	 */
-	EAttribute getDefaultValidatorsType_Id();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValueType <em>Default Value Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Default Value Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DefaultValueType
-	 * @generated
-	 */
-	EClass getDefaultValueType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValueType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DefaultValueType#getTextContent()
-	 * @see #getDefaultValueType()
-	 * @generated
-	 */
-	EAttribute getDefaultValueType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValueType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DefaultValueType#getId()
-	 * @see #getDefaultValueType()
-	 * @generated
-	 */
-	EAttribute getDefaultValueType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType <em>Description Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Description Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DescriptionType
-	 * @generated
-	 */
-	EClass getDescriptionType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DescriptionType#getTextContent()
-	 * @see #getDescriptionType()
-	 * @generated
-	 */
-	EAttribute getDescriptionType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType#getLang <em>Lang</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Lang</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DescriptionType#getLang()
-	 * @see #getDescriptionType()
-	 * @generated
-	 */
-	EAttribute getDescriptionType_Lang();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DescriptionType#getId()
-	 * @see #getDescriptionType()
-	 * @generated
-	 */
-	EAttribute getDescriptionType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType <em>Display Name Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Display Name Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType
-	 * @generated
-	 */
-	EClass getDisplayNameType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType#getTextContent()
-	 * @see #getDisplayNameType()
-	 * @generated
-	 */
-	EAttribute getDisplayNameType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType#getLang <em>Lang</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Lang</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType#getLang()
-	 * @see #getDisplayNameType()
-	 * @generated
-	 */
-	EAttribute getDisplayNameType_Lang();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType#getId()
-	 * @see #getDisplayNameType()
-	 * @generated
-	 */
-	EAttribute getDisplayNameType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot <em>Document Root</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Document Root</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot
-	 * @generated
-	 */
-	EClass getDocumentRoot();
-
-    /**
-	 * Returns the meta object for the attribute list '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getMixed <em>Mixed</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute list '<em>Mixed</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getMixed()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EAttribute getDocumentRoot_Mixed();
-
-    /**
-	 * Returns the meta object for the map '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getXMLNSPrefixMap <em>XMLNS Prefix Map</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the map '<em>XMLNS Prefix Map</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getXMLNSPrefixMap()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_XMLNSPrefixMap();
-
-    /**
-	 * Returns the meta object for the map '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getXSISchemaLocation <em>XSI Schema Location</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the map '<em>XSI Schema Location</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getXSISchemaLocation()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_XSISchemaLocation();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getAbsoluteOrdering <em>Absolute Ordering</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Absolute Ordering</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getAbsoluteOrdering()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_AbsoluteOrdering();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getActionListener <em>Action Listener</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Action Listener</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getActionListener()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ActionListener();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getApplication <em>Application</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Application</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getApplication()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_Application();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getApplicationFactory <em>Application Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Application Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getApplicationFactory()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ApplicationFactory();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getAttribute <em>Attribute</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Attribute</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getAttribute()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_Attribute();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getAttributeClass <em>Attribute Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Attribute Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getAttributeClass()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_AttributeClass();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getAttributeExtension <em>Attribute Extension</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Attribute Extension</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getAttributeExtension()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_AttributeExtension();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getAttributeName <em>Attribute Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Attribute Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getAttributeName()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_AttributeName();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getBehavior <em>Behavior</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Behavior</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getBehavior()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_Behavior();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getBehaviorClass <em>Behavior Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Behavior Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getBehaviorClass()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_BehaviorClass();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getBehaviorId <em>Behavior Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Behavior Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getBehaviorId()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_BehaviorId();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getBehaviorExtension <em>Behavior Extension</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Behavior Extension</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getBehaviorExtension()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_BehaviorExtension();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getComponent <em>Component</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Component</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getComponent()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_Component();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getComponentClass <em>Component Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Component Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getComponentClass()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ComponentClass();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getComponentExtension <em>Component Extension</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Component Extension</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getComponentExtension()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ComponentExtension();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getComponentFamily <em>Component Family</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Component Family</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getComponentFamily()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ComponentFamily();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getComponentType <em>Component Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Component Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getComponentType()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ComponentType();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getConverter <em>Converter</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Converter</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getConverter()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_Converter();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getConverterClass <em>Converter Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Converter Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getConverterClass()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ConverterClass();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getConverterForClass <em>Converter For Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Converter For Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getConverterForClass()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ConverterForClass();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getConverterId <em>Converter Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Converter Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getConverterId()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ConverterId();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDefaultLocale <em>Default Locale</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Default Locale</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDefaultLocale()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_DefaultLocale();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDefaultRenderKitId <em>Default Render Kit Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Default Render Kit Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDefaultRenderKitId()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_DefaultRenderKitId();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDefaultValidators <em>Default Validators</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Default Validators</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDefaultValidators()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_DefaultValidators();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDefaultValue <em>Default Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Default Value</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDefaultValue()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_DefaultValue();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDescription <em>Description</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Description</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDescription()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_Description();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDisplayName <em>Display Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Display Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getDisplayName()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_DisplayName();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getExceptionHandlerFactory <em>Exception Handler Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Exception Handler Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getExceptionHandlerFactory()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ExceptionHandlerFactory();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getExternalContextFactory <em>External Context Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>External Context Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getExternalContextFactory()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ExternalContextFactory();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFacesConfig <em>Faces Config</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Faces Config</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFacesConfig()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_FacesConfig();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFacesContextFactory <em>Faces Context Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Faces Context Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFacesContextFactory()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_FacesContextFactory();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFacet <em>Facet</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Facet</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFacet()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_Facet();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFacetExtension <em>Facet Extension</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Facet Extension</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFacetExtension()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_FacetExtension();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFacetName <em>Facet Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Facet Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFacetName()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_FacetName();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFactory <em>Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFactory()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_Factory();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFromAction <em>From Action</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>From Action</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFromAction()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_FromAction();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFromOutcome <em>From Outcome</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>From Outcome</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFromOutcome()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_FromOutcome();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFromViewId <em>From View Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>From View Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getFromViewId()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_FromViewId();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getIcon <em>Icon</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Icon</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getIcon()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_Icon();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getIf <em>If</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>If</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getIf()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_If();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getKey <em>Key</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Key</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getKey()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_Key();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getKeyClass <em>Key Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Key Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getKeyClass()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_KeyClass();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getLargeIcon <em>Large Icon</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Large Icon</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getLargeIcon()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_LargeIcon();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getLifecycle <em>Lifecycle</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Lifecycle</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getLifecycle()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_Lifecycle();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getLifecycleFactory <em>Lifecycle Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Lifecycle Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getLifecycleFactory()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_LifecycleFactory();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getListEntries <em>List Entries</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>List Entries</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getListEntries()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ListEntries();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getLocaleConfig <em>Locale Config</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Locale Config</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getLocaleConfig()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_LocaleConfig();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getManagedBean <em>Managed Bean</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Managed Bean</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getManagedBean()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ManagedBean();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getManagedBeanClass <em>Managed Bean Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Managed Bean Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getManagedBeanClass()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ManagedBeanClass();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getManagedBeanName <em>Managed Bean Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Managed Bean Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getManagedBeanName()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ManagedBeanName();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getManagedBeanScope <em>Managed Bean Scope</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Managed Bean Scope</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getManagedBeanScope()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ManagedBeanScope();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getManagedProperty <em>Managed Property</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Managed Property</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getManagedProperty()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ManagedProperty();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getMapEntries <em>Map Entries</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Map Entries</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getMapEntries()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_MapEntries();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getMapEntry <em>Map Entry</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Map Entry</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getMapEntry()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_MapEntry();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getMessageBundle <em>Message Bundle</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Message Bundle</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getMessageBundle()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_MessageBundle();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getName <em>Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getName()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_Name();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getNavigationCase <em>Navigation Case</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Navigation Case</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getNavigationCase()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_NavigationCase();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getNavigationHandler <em>Navigation Handler</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Navigation Handler</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getNavigationHandler()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_NavigationHandler();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getNavigationRule <em>Navigation Rule</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Navigation Rule</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getNavigationRule()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_NavigationRule();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getNullValue <em>Null Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Null Value</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getNullValue()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_NullValue();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getOrdering <em>Ordering</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Ordering</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getOrdering()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_Ordering();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getOrderingOrdering <em>Ordering Ordering</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Ordering Ordering</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getOrderingOrdering()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_OrderingOrdering();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getOthers <em>Others</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Others</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getOthers()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_Others();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPartialViewContextFactory <em>Partial View Context Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Partial View Context Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPartialViewContextFactory()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_PartialViewContextFactory();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPhaseListener <em>Phase Listener</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Phase Listener</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPhaseListener()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_PhaseListener();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getProperty <em>Property</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Property</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getProperty()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_Property();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPropertyClass <em>Property Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Property Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPropertyClass()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_PropertyClass();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPropertyExtension <em>Property Extension</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Property Extension</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPropertyExtension()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_PropertyExtension();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPropertyName <em>Property Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Property Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPropertyName()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_PropertyName();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPropertyResolver <em>Property Resolver</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Property Resolver</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getPropertyResolver()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_PropertyResolver();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRedirect <em>Redirect</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Redirect</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRedirect()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_Redirect();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRedirectViewParam <em>Redirect View Param</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Redirect View Param</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRedirectViewParam()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_RedirectViewParam();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getReferencedBean <em>Referenced Bean</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Referenced Bean</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getReferencedBean()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ReferencedBean();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getReferencedBeanClass <em>Referenced Bean Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Referenced Bean Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getReferencedBeanClass()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ReferencedBeanClass();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getReferencedBeanName <em>Referenced Bean Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Referenced Bean Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getReferencedBeanName()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ReferencedBeanName();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRenderer <em>Renderer</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Renderer</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRenderer()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_Renderer();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRendererClass <em>Renderer Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Renderer Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRendererClass()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_RendererClass();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRendererExtension <em>Renderer Extension</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Renderer Extension</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRendererExtension()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_RendererExtension();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRendererType <em>Renderer Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Renderer Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRendererType()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_RendererType();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRenderKit <em>Render Kit</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Render Kit</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRenderKit()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_RenderKit();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRenderKitClass <em>Render Kit Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Render Kit Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRenderKitClass()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_RenderKitClass();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRenderKitFactory <em>Render Kit Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Render Kit Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRenderKitFactory()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_RenderKitFactory();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRenderKitId <em>Render Kit Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Render Kit Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getRenderKitId()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_RenderKitId();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getResourceHandler <em>Resource Handler</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Resource Handler</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getResourceHandler()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ResourceHandler();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSmallIcon <em>Small Icon</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Small Icon</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSmallIcon()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_SmallIcon();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSourceClass <em>Source Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Source Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSourceClass()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_SourceClass();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getStateManager <em>State Manager</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>State Manager</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getStateManager()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_StateManager();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSuggestedValue <em>Suggested Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Suggested Value</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSuggestedValue()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_SuggestedValue();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSupportedLocale <em>Supported Locale</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Supported Locale</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSupportedLocale()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_SupportedLocale();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSystemEventClass <em>System Event Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>System Event Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSystemEventClass()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_SystemEventClass();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSystemEventListener <em>System Event Listener</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>System Event Listener</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSystemEventListener()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_SystemEventListener();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSystemEventListenerClass <em>System Event Listener Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>System Event Listener Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getSystemEventListenerClass()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_SystemEventListenerClass();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getTagHandlerDelegateFactory <em>Tag Handler Delegate Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Tag Handler Delegate Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getTagHandlerDelegateFactory()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_TagHandlerDelegateFactory();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getToViewId <em>To View Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>To View Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getToViewId()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ToViewId();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getValidator <em>Validator</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Validator</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getValidator()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_Validator();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getValidatorClass <em>Validator Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Validator Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getValidatorClass()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ValidatorClass();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getValidatorId <em>Validator Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Validator Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getValidatorId()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ValidatorId();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getValue <em>Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Value</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getValue()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_Value();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getValueClass <em>Value Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Value Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getValueClass()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ValueClass();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getVariableResolver <em>Variable Resolver</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Variable Resolver</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getVariableResolver()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_VariableResolver();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getViewDeclarationLanguageFactory <em>View Declaration Language Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>View Declaration Language Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getViewDeclarationLanguageFactory()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ViewDeclarationLanguageFactory();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getViewHandler <em>View Handler</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>View Handler</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getViewHandler()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_ViewHandler();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getVisitContextFactory <em>Visit Context Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Visit Context Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot#getVisitContextFactory()
-	 * @see #getDocumentRoot()
-	 * @generated
-	 */
-	EReference getDocumentRoot_VisitContextFactory();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.DynamicAttribute <em>Dynamic Attribute</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Dynamic Attribute</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DynamicAttribute
-	 * @generated
-	 */
-    EClass getDynamicAttribute();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.DynamicAttribute#getName <em>Name</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DynamicAttribute#getName()
-	 * @see #getDynamicAttribute()
-	 * @generated
-	 */
-    EAttribute getDynamicAttribute_Name();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.DynamicAttribute#getValue <em>Value</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Value</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DynamicAttribute#getValue()
-	 * @see #getDynamicAttribute()
-	 * @generated
-	 */
-    EAttribute getDynamicAttribute_Value();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.DynamicElement <em>Dynamic Element</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Dynamic Element</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DynamicElement
-	 * @generated
-	 */
-    EClass getDynamicElement();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.DynamicElement#getChildNodes <em>Child Nodes</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Child Nodes</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DynamicElement#getChildNodes()
-	 * @see #getDynamicElement()
-	 * @generated
-	 */
-    EReference getDynamicElement_ChildNodes();
-
-    /**
-	 * Returns the meta object for the reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.DynamicElement#getAttributes <em>Attributes</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the reference list '<em>Attributes</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DynamicElement#getAttributes()
-	 * @see #getDynamicElement()
-	 * @generated
-	 */
-    EReference getDynamicElement_Attributes();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.DynamicElement#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DynamicElement#getTextContent()
-	 * @see #getDynamicElement()
-	 * @generated
-	 */
-    EAttribute getDynamicElement_TextContent();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ELResolverType <em>EL Resolver Type</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>EL Resolver Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ELResolverType
-	 * @generated
-	 */
-    EClass getELResolverType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ELResolverType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ELResolverType#getTextContent()
-	 * @see #getELResolverType()
-	 * @generated
-	 */
-    EAttribute getELResolverType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ELResolverType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ELResolverType#getId()
-	 * @see #getELResolverType()
-	 * @generated
-	 */
-    EAttribute getELResolverType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ExceptionHandlerFactoryType <em>Exception Handler Factory Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Exception Handler Factory Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ExceptionHandlerFactoryType
-	 * @generated
-	 */
-	EClass getExceptionHandlerFactoryType();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ExceptionHandlerFactoryType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ExceptionHandlerFactoryType#getTextContent()
-	 * @see #getExceptionHandlerFactoryType()
-	 * @generated
-	 */
-	EAttribute getExceptionHandlerFactoryType_TextContent();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ExceptionHandlerFactoryType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ExceptionHandlerFactoryType#getId()
-	 * @see #getExceptionHandlerFactoryType()
-	 * @generated
-	 */
-	EAttribute getExceptionHandlerFactoryType_Id();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.DynamicElement#getName <em>Name</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.DynamicElement#getName()
-	 * @see #getDynamicElement()
-	 * @generated
-	 */
-    EAttribute getDynamicElement_Name();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType <em>Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType
-	 * @generated
-	 */
-	EClass getFacesConfigType();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getApplication <em>Application</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Application</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getApplication()
-	 * @see #getFacesConfigType()
-	 * @generated
-	 */
-	EReference getFacesConfigType_Application();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getOrdering <em>Ordering</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Ordering</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getOrdering()
-	 * @see #getFacesConfigType()
-	 * @generated
-	 */
-	EReference getFacesConfigType_Ordering();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getAbsoluteOrdering <em>Absolute Ordering</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Absolute Ordering</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getAbsoluteOrdering()
-	 * @see #getFacesConfigType()
-	 * @generated
-	 */
-	EReference getFacesConfigType_AbsoluteOrdering();
-
-				/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getFactory <em>Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getFactory()
-	 * @see #getFacesConfigType()
-	 * @generated
-	 */
-	EReference getFacesConfigType_Factory();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getComponent <em>Component</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Component</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getComponent()
-	 * @see #getFacesConfigType()
-	 * @generated
-	 */
-	EReference getFacesConfigType_Component();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getConverter <em>Converter</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Converter</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getConverter()
-	 * @see #getFacesConfigType()
-	 * @generated
-	 */
-	EReference getFacesConfigType_Converter();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getManagedBean <em>Managed Bean</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Managed Bean</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getManagedBean()
-	 * @see #getFacesConfigType()
-	 * @generated
-	 */
-	EReference getFacesConfigType_ManagedBean();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getName <em>Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getName()
-	 * @see #getFacesConfigType()
-	 * @generated
-	 */
-	EReference getFacesConfigType_Name();
-
-				/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getNavigationRule <em>Navigation Rule</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Navigation Rule</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getNavigationRule()
-	 * @see #getFacesConfigType()
-	 * @generated
-	 */
-	EReference getFacesConfigType_NavigationRule();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getReferencedBean <em>Referenced Bean</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Referenced Bean</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getReferencedBean()
-	 * @see #getFacesConfigType()
-	 * @generated
-	 */
-	EReference getFacesConfigType_ReferencedBean();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getRenderKit <em>Render Kit</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Render Kit</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getRenderKit()
-	 * @see #getFacesConfigType()
-	 * @generated
-	 */
-	EReference getFacesConfigType_RenderKit();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getLifecycle <em>Lifecycle</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Lifecycle</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getLifecycle()
-	 * @see #getFacesConfigType()
-	 * @generated
-	 */
-	EReference getFacesConfigType_Lifecycle();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getValidator <em>Validator</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Validator</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getValidator()
-	 * @see #getFacesConfigType()
-	 * @generated
-	 */
-	EReference getFacesConfigType_Validator();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getBehavior <em>Behavior</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Behavior</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getBehavior()
-	 * @see #getFacesConfigType()
-	 * @generated
-	 */
-	EReference getFacesConfigType_Behavior();
-
-				/**
-	 * Returns the meta object for the reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getFacesConfigExtension <em>Faces Config Extension</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the reference list '<em>Faces Config Extension</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getFacesConfigExtension()
-	 * @see #getFacesConfigType()
-	 * @generated
-	 */
-    EReference getFacesConfigType_FacesConfigExtension();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getXmlns <em>Xmlns</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Xmlns</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getXmlns()
-	 * @see #getFacesConfigType()
-	 * @generated
-	 */
-	EAttribute getFacesConfigType_Xmlns();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getId()
-	 * @see #getFacesConfigType()
-	 * @generated
-	 */
-	EAttribute getFacesConfigType_Id();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#isMetadataComplete <em>Metadata Complete</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Metadata Complete</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#isMetadataComplete()
-	 * @see #getFacesConfigType()
-	 * @generated
-	 */
-	EAttribute getFacesConfigType_MetadataComplete();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesContextFactoryType <em>Faces Context Factory Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Faces Context Factory Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesContextFactoryType
-	 * @generated
-	 */
-	EClass getFacesContextFactoryType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesContextFactoryType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesContextFactoryType#getTextContent()
-	 * @see #getFacesContextFactoryType()
-	 * @generated
-	 */
-	EAttribute getFacesContextFactoryType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesContextFactoryType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesContextFactoryType#getId()
-	 * @see #getFacesContextFactoryType()
-	 * @generated
-	 */
-	EAttribute getFacesContextFactoryType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.FacetExtensionType <em>Facet Extension Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Facet Extension Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacetExtensionType
-	 * @generated
-	 */
-	EClass getFacetExtensionType();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.FacetNameType <em>Facet Name Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Facet Name Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacetNameType
-	 * @generated
-	 */
-	EClass getFacetNameType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.FacetNameType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacetNameType#getTextContent()
-	 * @see #getFacetNameType()
-	 * @generated
-	 */
-	EAttribute getFacetNameType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.FacetNameType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacetNameType#getId()
-	 * @see #getFacetNameType()
-	 * @generated
-	 */
-	EAttribute getFacetNameType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.FacetType <em>Facet Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Facet Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacetType
-	 * @generated
-	 */
-	EClass getFacetType();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FacetType#getDescription <em>Description</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Description</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacetType#getDescription()
-	 * @see #getFacetType()
-	 * @generated
-	 */
-	EReference getFacetType_Description();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FacetType#getDisplayName <em>Display Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Display Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacetType#getDisplayName()
-	 * @see #getFacetType()
-	 * @generated
-	 */
-	EReference getFacetType_DisplayName();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FacetType#getIcon <em>Icon</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Icon</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacetType#getIcon()
-	 * @see #getFacetType()
-	 * @generated
-	 */
-	EReference getFacetType_Icon();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.FacetType#getFacetName <em>Facet Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Facet Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacetType#getFacetName()
-	 * @see #getFacetType()
-	 * @generated
-	 */
-	EReference getFacetType_FacetName();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FacetType#getFacetExtension <em>Facet Extension</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Facet Extension</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacetType#getFacetExtension()
-	 * @see #getFacetType()
-	 * @generated
-	 */
-	EReference getFacetType_FacetExtension();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.FacetType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacetType#getId()
-	 * @see #getFacetType()
-	 * @generated
-	 */
-	EAttribute getFacetType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType <em>Factory Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Factory Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FactoryType
-	 * @generated
-	 */
-	EClass getFactoryType();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getApplicationFactory <em>Application Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Application Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getApplicationFactory()
-	 * @see #getFactoryType()
-	 * @generated
-	 */
-	EReference getFactoryType_ApplicationFactory();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getExceptionHandlerFactory <em>Exception Handler Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Exception Handler Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getExceptionHandlerFactory()
-	 * @see #getFactoryType()
-	 * @generated
-	 */
-	EReference getFactoryType_ExceptionHandlerFactory();
-
-				/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getExternalContextFactory <em>External Context Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>External Context Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getExternalContextFactory()
-	 * @see #getFactoryType()
-	 * @generated
-	 */
-	EReference getFactoryType_ExternalContextFactory();
-
-				/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getFacesContextFactory <em>Faces Context Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Faces Context Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getFacesContextFactory()
-	 * @see #getFactoryType()
-	 * @generated
-	 */
-	EReference getFactoryType_FacesContextFactory();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getPartialViewContextFactory <em>Partial View Context Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Partial View Context Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getPartialViewContextFactory()
-	 * @see #getFactoryType()
-	 * @generated
-	 */
-	EReference getFactoryType_PartialViewContextFactory();
-
-				/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getLifecycleFactory <em>Lifecycle Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Lifecycle Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getLifecycleFactory()
-	 * @see #getFactoryType()
-	 * @generated
-	 */
-	EReference getFactoryType_LifecycleFactory();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getViewDeclarationLanguageFactory <em>View Declaration Language Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>View Declaration Language Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getViewDeclarationLanguageFactory()
-	 * @see #getFactoryType()
-	 * @generated
-	 */
-	EReference getFactoryType_ViewDeclarationLanguageFactory();
-
-				/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getTagHandlerDelegateFactory <em>Tag Handler Delegate Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Tag Handler Delegate Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getTagHandlerDelegateFactory()
-	 * @see #getFactoryType()
-	 * @generated
-	 */
-	EReference getFactoryType_TagHandlerDelegateFactory();
-
-				/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getRenderKitFactory <em>Render Kit Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Render Kit Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getRenderKitFactory()
-	 * @see #getFactoryType()
-	 * @generated
-	 */
-	EReference getFactoryType_RenderKitFactory();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getVisitContextFactory <em>Visit Context Factory</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Visit Context Factory</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getVisitContextFactory()
-	 * @see #getFactoryType()
-	 * @generated
-	 */
-	EReference getFactoryType_VisitContextFactory();
-
-				/**
-	 * Returns the meta object for the reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getFactoryExtension <em>Factory Extension</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the reference list '<em>Factory Extension</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getFactoryExtension()
-	 * @see #getFactoryType()
-	 * @generated
-	 */
-    EReference getFactoryType_FactoryExtension();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getId()
-	 * @see #getFactoryType()
-	 * @generated
-	 */
-	EAttribute getFactoryType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.FromActionType <em>From Action Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>From Action Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FromActionType
-	 * @generated
-	 */
-	EClass getFromActionType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.FromActionType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FromActionType#getTextContent()
-	 * @see #getFromActionType()
-	 * @generated
-	 */
-	EAttribute getFromActionType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.FromActionType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FromActionType#getId()
-	 * @see #getFromActionType()
-	 * @generated
-	 */
-	EAttribute getFromActionType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.FromOutcomeType <em>From Outcome Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>From Outcome Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FromOutcomeType
-	 * @generated
-	 */
-	EClass getFromOutcomeType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.FromOutcomeType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FromOutcomeType#getTextContent()
-	 * @see #getFromOutcomeType()
-	 * @generated
-	 */
-	EAttribute getFromOutcomeType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.FromOutcomeType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FromOutcomeType#getId()
-	 * @see #getFromOutcomeType()
-	 * @generated
-	 */
-	EAttribute getFromOutcomeType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.FromViewIdType <em>From View Id Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>From View Id Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FromViewIdType
-	 * @generated
-	 */
-	EClass getFromViewIdType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.FromViewIdType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FromViewIdType#getTextContent()
-	 * @see #getFromViewIdType()
-	 * @generated
-	 */
-	EAttribute getFromViewIdType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.FromViewIdType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FromViewIdType#getId()
-	 * @see #getFromViewIdType()
-	 * @generated
-	 */
-	EAttribute getFromViewIdType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.IconType <em>Icon Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Icon Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.IconType
-	 * @generated
-	 */
-	EClass getIconType();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.IconType#getSmallIcon <em>Small Icon</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Small Icon</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.IconType#getSmallIcon()
-	 * @see #getIconType()
-	 * @generated
-	 */
-	EReference getIconType_SmallIcon();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.IconType#getLargeIcon <em>Large Icon</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Large Icon</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.IconType#getLargeIcon()
-	 * @see #getIconType()
-	 * @generated
-	 */
-	EReference getIconType_LargeIcon();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.IconType#getLang <em>Lang</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Lang</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.IconType#getLang()
-	 * @see #getIconType()
-	 * @generated
-	 */
-	EAttribute getIconType_Lang();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.IconType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.IconType#getId()
-	 * @see #getIconType()
-	 * @generated
-	 */
-	EAttribute getIconType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.IfType <em>If Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>If Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.IfType
-	 * @generated
-	 */
-	EClass getIfType();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.IfType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.IfType#getTextContent()
-	 * @see #getIfType()
-	 * @generated
-	 */
-	EAttribute getIfType_TextContent();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.IfType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.IfType#getId()
-	 * @see #getIfType()
-	 * @generated
-	 */
-	EAttribute getIfType_Id();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.KeyClassType <em>Key Class Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Key Class Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.KeyClassType
-	 * @generated
-	 */
-	EClass getKeyClassType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.KeyClassType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.KeyClassType#getTextContent()
-	 * @see #getKeyClassType()
-	 * @generated
-	 */
-	EAttribute getKeyClassType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.KeyClassType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.KeyClassType#getId()
-	 * @see #getKeyClassType()
-	 * @generated
-	 */
-	EAttribute getKeyClassType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.KeyType <em>Key Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Key Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.KeyType
-	 * @generated
-	 */
-	EClass getKeyType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.KeyType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.KeyType#getTextContent()
-	 * @see #getKeyType()
-	 * @generated
-	 */
-	EAttribute getKeyType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.KeyType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.KeyType#getId()
-	 * @see #getKeyType()
-	 * @generated
-	 */
-	EAttribute getKeyType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.LargeIconType <em>Large Icon Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Large Icon Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.LargeIconType
-	 * @generated
-	 */
-	EClass getLargeIconType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.LargeIconType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.LargeIconType#getTextContent()
-	 * @see #getLargeIconType()
-	 * @generated
-	 */
-	EAttribute getLargeIconType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.LargeIconType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.LargeIconType#getId()
-	 * @see #getLargeIconType()
-	 * @generated
-	 */
-	EAttribute getLargeIconType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleFactoryType <em>Lifecycle Factory Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Lifecycle Factory Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.LifecycleFactoryType
-	 * @generated
-	 */
-	EClass getLifecycleFactoryType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleFactoryType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.LifecycleFactoryType#getTextContent()
-	 * @see #getLifecycleFactoryType()
-	 * @generated
-	 */
-	EAttribute getLifecycleFactoryType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleFactoryType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.LifecycleFactoryType#getId()
-	 * @see #getLifecycleFactoryType()
-	 * @generated
-	 */
-	EAttribute getLifecycleFactoryType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleType <em>Lifecycle Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Lifecycle Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.LifecycleType
-	 * @generated
-	 */
-	EClass getLifecycleType();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleType#getPhaseListener <em>Phase Listener</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Phase Listener</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.LifecycleType#getPhaseListener()
-	 * @see #getLifecycleType()
-	 * @generated
-	 */
-	EReference getLifecycleType_PhaseListener();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleType#getLifecycleExtension <em>Lifecycle Extension</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Lifecycle Extension</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.LifecycleType#getLifecycleExtension()
-	 * @see #getLifecycleType()
-	 * @generated
-	 */
-    EReference getLifecycleType_LifecycleExtension();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.LifecycleType#getId()
-	 * @see #getLifecycleType()
-	 * @generated
-	 */
-	EAttribute getLifecycleType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType <em>List Entries Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>List Entries Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType
-	 * @generated
-	 */
-	EClass getListEntriesType();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType#getValueClass <em>Value Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Value Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType#getValueClass()
-	 * @see #getListEntriesType()
-	 * @generated
-	 */
-	EReference getListEntriesType_ValueClass();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType#getNullValue <em>Null Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Null Value</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType#getNullValue()
-	 * @see #getListEntriesType()
-	 * @generated
-	 */
-	EReference getListEntriesType_NullValue();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType#getValue <em>Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Value</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType#getValue()
-	 * @see #getListEntriesType()
-	 * @generated
-	 */
-	EReference getListEntriesType_Value();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType#getId()
-	 * @see #getListEntriesType()
-	 * @generated
-	 */
-	EAttribute getListEntriesType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType <em>Locale Config Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Locale Config Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType
-	 * @generated
-	 */
-	EClass getLocaleConfigType();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType#getDefaultLocale <em>Default Locale</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Default Locale</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType#getDefaultLocale()
-	 * @see #getLocaleConfigType()
-	 * @generated
-	 */
-	EReference getLocaleConfigType_DefaultLocale();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType#getSupportedLocale <em>Supported Locale</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Supported Locale</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType#getSupportedLocale()
-	 * @see #getLocaleConfigType()
-	 * @generated
-	 */
-	EReference getLocaleConfigType_SupportedLocale();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType#getId()
-	 * @see #getLocaleConfigType()
-	 * @generated
-	 */
-	EAttribute getLocaleConfigType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanClassType <em>Managed Bean Class Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Managed Bean Class Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanClassType
-	 * @generated
-	 */
-	EClass getManagedBeanClassType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanClassType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanClassType#getTextContent()
-	 * @see #getManagedBeanClassType()
-	 * @generated
-	 */
-	EAttribute getManagedBeanClassType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanClassType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanClassType#getId()
-	 * @see #getManagedBeanClassType()
-	 * @generated
-	 */
-	EAttribute getManagedBeanClassType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanNameType <em>Managed Bean Name Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Managed Bean Name Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanNameType
-	 * @generated
-	 */
-	EClass getManagedBeanNameType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanNameType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanNameType#getTextContent()
-	 * @see #getManagedBeanNameType()
-	 * @generated
-	 */
-	EAttribute getManagedBeanNameType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanNameType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanNameType#getId()
-	 * @see #getManagedBeanNameType()
-	 * @generated
-	 */
-	EAttribute getManagedBeanNameType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanScopeType <em>Managed Bean Scope Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Managed Bean Scope Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanScopeType
-	 * @generated
-	 */
-	EClass getManagedBeanScopeType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanScopeType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanScopeType#getTextContent()
-	 * @see #getManagedBeanScopeType()
-	 * @generated
-	 */
-	EAttribute getManagedBeanScopeType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanScopeType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanScopeType#getId()
-	 * @see #getManagedBeanScopeType()
-	 * @generated
-	 */
-	EAttribute getManagedBeanScopeType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType <em>Managed Bean Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Managed Bean Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType
-	 * @generated
-	 */
-	EClass getManagedBeanType();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getDescription <em>Description</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Description</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getDescription()
-	 * @see #getManagedBeanType()
-	 * @generated
-	 */
-	EReference getManagedBeanType_Description();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getDisplayName <em>Display Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Display Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getDisplayName()
-	 * @see #getManagedBeanType()
-	 * @generated
-	 */
-	EReference getManagedBeanType_DisplayName();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getIcon <em>Icon</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Icon</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getIcon()
-	 * @see #getManagedBeanType()
-	 * @generated
-	 */
-	EReference getManagedBeanType_Icon();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getManagedBeanName <em>Managed Bean Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Managed Bean Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getManagedBeanName()
-	 * @see #getManagedBeanType()
-	 * @generated
-	 */
-	EReference getManagedBeanType_ManagedBeanName();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getManagedBeanClass <em>Managed Bean Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Managed Bean Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getManagedBeanClass()
-	 * @see #getManagedBeanType()
-	 * @generated
-	 */
-	EReference getManagedBeanType_ManagedBeanClass();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getManagedBeanScope <em>Managed Bean Scope</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Managed Bean Scope</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getManagedBeanScope()
-	 * @see #getManagedBeanType()
-	 * @generated
-	 */
-	EReference getManagedBeanType_ManagedBeanScope();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getManagedProperty <em>Managed Property</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Managed Property</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getManagedProperty()
-	 * @see #getManagedBeanType()
-	 * @generated
-	 */
-	EReference getManagedBeanType_ManagedProperty();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getMapEntries <em>Map Entries</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Map Entries</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getMapEntries()
-	 * @see #getManagedBeanType()
-	 * @generated
-	 */
-	EReference getManagedBeanType_MapEntries();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getListEntries <em>List Entries</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>List Entries</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getListEntries()
-	 * @see #getManagedBeanType()
-	 * @generated
-	 */
-	EReference getManagedBeanType_ListEntries();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getManagedBeanExtension <em>Managed Bean Extension</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Managed Bean Extension</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getManagedBeanExtension()
-	 * @see #getManagedBeanType()
-	 * @generated
-	 */
-    EReference getManagedBeanType_ManagedBeanExtension();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getId()
-	 * @see #getManagedBeanType()
-	 * @generated
-	 */
-	EAttribute getManagedBeanType_Id();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#isEager <em>Eager</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Eager</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#isEager()
-	 * @see #getManagedBeanType()
-	 * @generated
-	 */
-	EAttribute getManagedBeanType_Eager();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType <em>Managed Property Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Managed Property Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType
-	 * @generated
-	 */
-	EClass getManagedPropertyType();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getDescription <em>Description</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Description</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getDescription()
-	 * @see #getManagedPropertyType()
-	 * @generated
-	 */
-	EReference getManagedPropertyType_Description();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getDisplayName <em>Display Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Display Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getDisplayName()
-	 * @see #getManagedPropertyType()
-	 * @generated
-	 */
-	EReference getManagedPropertyType_DisplayName();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getIcon <em>Icon</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Icon</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getIcon()
-	 * @see #getManagedPropertyType()
-	 * @generated
-	 */
-	EReference getManagedPropertyType_Icon();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getPropertyName <em>Property Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Property Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getPropertyName()
-	 * @see #getManagedPropertyType()
-	 * @generated
-	 */
-	EReference getManagedPropertyType_PropertyName();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getPropertyClass <em>Property Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Property Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getPropertyClass()
-	 * @see #getManagedPropertyType()
-	 * @generated
-	 */
-	EReference getManagedPropertyType_PropertyClass();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getMapEntries <em>Map Entries</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Map Entries</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getMapEntries()
-	 * @see #getManagedPropertyType()
-	 * @generated
-	 */
-	EReference getManagedPropertyType_MapEntries();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getNullValue <em>Null Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Null Value</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getNullValue()
-	 * @see #getManagedPropertyType()
-	 * @generated
-	 */
-	EReference getManagedPropertyType_NullValue();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getValue <em>Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Value</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getValue()
-	 * @see #getManagedPropertyType()
-	 * @generated
-	 */
-	EReference getManagedPropertyType_Value();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getListEntries <em>List Entries</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>List Entries</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getListEntries()
-	 * @see #getManagedPropertyType()
-	 * @generated
-	 */
-	EReference getManagedPropertyType_ListEntries();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getId()
-	 * @see #getManagedPropertyType()
-	 * @generated
-	 */
-	EAttribute getManagedPropertyType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType <em>Map Entries Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Map Entries Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType
-	 * @generated
-	 */
-	EClass getMapEntriesType();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType#getKeyClass <em>Key Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Key Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType#getKeyClass()
-	 * @see #getMapEntriesType()
-	 * @generated
-	 */
-	EReference getMapEntriesType_KeyClass();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType#getValueClass <em>Value Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Value Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType#getValueClass()
-	 * @see #getMapEntriesType()
-	 * @generated
-	 */
-	EReference getMapEntriesType_ValueClass();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType#getMapEntry <em>Map Entry</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Map Entry</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType#getMapEntry()
-	 * @see #getMapEntriesType()
-	 * @generated
-	 */
-	EReference getMapEntriesType_MapEntry();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType#getId()
-	 * @see #getMapEntriesType()
-	 * @generated
-	 */
-	EAttribute getMapEntriesType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntryType <em>Map Entry Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Map Entry Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.MapEntryType
-	 * @generated
-	 */
-	EClass getMapEntryType();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntryType#getKey <em>Key</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Key</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.MapEntryType#getKey()
-	 * @see #getMapEntryType()
-	 * @generated
-	 */
-	EReference getMapEntryType_Key();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntryType#getNullValue <em>Null Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Null Value</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.MapEntryType#getNullValue()
-	 * @see #getMapEntryType()
-	 * @generated
-	 */
-	EReference getMapEntryType_NullValue();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntryType#getValue <em>Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Value</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.MapEntryType#getValue()
-	 * @see #getMapEntryType()
-	 * @generated
-	 */
-	EReference getMapEntryType_Value();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntryType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.MapEntryType#getId()
-	 * @see #getMapEntryType()
-	 * @generated
-	 */
-	EAttribute getMapEntryType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.MessageBundleType <em>Message Bundle Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Message Bundle Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.MessageBundleType
-	 * @generated
-	 */
-	EClass getMessageBundleType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.MessageBundleType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.MessageBundleType#getTextContent()
-	 * @see #getMessageBundleType()
-	 * @generated
-	 */
-	EAttribute getMessageBundleType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.MessageBundleType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.MessageBundleType#getId()
-	 * @see #getMessageBundleType()
-	 * @generated
-	 */
-	EAttribute getMessageBundleType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.NameType <em>Name Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Name Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NameType
-	 * @generated
-	 */
-	EClass getNameType();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.NameType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NameType#getTextContent()
-	 * @see #getNameType()
-	 * @generated
-	 */
-	EAttribute getNameType_TextContent();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.NameType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NameType#getId()
-	 * @see #getNameType()
-	 * @generated
-	 */
-	EAttribute getNameType_Id();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType <em>Navigation Case Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Navigation Case Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType
-	 * @generated
-	 */
-	EClass getNavigationCaseType();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getDescription <em>Description</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Description</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getDescription()
-	 * @see #getNavigationCaseType()
-	 * @generated
-	 */
-	EReference getNavigationCaseType_Description();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getDisplayName <em>Display Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Display Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getDisplayName()
-	 * @see #getNavigationCaseType()
-	 * @generated
-	 */
-	EReference getNavigationCaseType_DisplayName();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getIcon <em>Icon</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Icon</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getIcon()
-	 * @see #getNavigationCaseType()
-	 * @generated
-	 */
-	EReference getNavigationCaseType_Icon();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getFromAction <em>From Action</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>From Action</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getFromAction()
-	 * @see #getNavigationCaseType()
-	 * @generated
-	 */
-	EReference getNavigationCaseType_FromAction();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getFromOutcome <em>From Outcome</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>From Outcome</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getFromOutcome()
-	 * @see #getNavigationCaseType()
-	 * @generated
-	 */
-	EReference getNavigationCaseType_FromOutcome();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getIf <em>If</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>If</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getIf()
-	 * @see #getNavigationCaseType()
-	 * @generated
-	 */
-	EReference getNavigationCaseType_If();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getToViewId <em>To View Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>To View Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getToViewId()
-	 * @see #getNavigationCaseType()
-	 * @generated
-	 */
-	EReference getNavigationCaseType_ToViewId();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getRedirect <em>Redirect</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Redirect</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getRedirect()
-	 * @see #getNavigationCaseType()
-	 * @generated
-	 */
-	EReference getNavigationCaseType_Redirect();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getId()
-	 * @see #getNavigationCaseType()
-	 * @generated
-	 */
-	EAttribute getNavigationCaseType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationHandlerType <em>Navigation Handler Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Navigation Handler Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationHandlerType
-	 * @generated
-	 */
-	EClass getNavigationHandlerType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationHandlerType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationHandlerType#getTextContent()
-	 * @see #getNavigationHandlerType()
-	 * @generated
-	 */
-	EAttribute getNavigationHandlerType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationHandlerType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationHandlerType#getId()
-	 * @see #getNavigationHandlerType()
-	 * @generated
-	 */
-	EAttribute getNavigationHandlerType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType <em>Navigation Rule Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Navigation Rule Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType
-	 * @generated
-	 */
-	EClass getNavigationRuleType();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getDescription <em>Description</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Description</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getDescription()
-	 * @see #getNavigationRuleType()
-	 * @generated
-	 */
-	EReference getNavigationRuleType_Description();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getDisplayName <em>Display Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Display Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getDisplayName()
-	 * @see #getNavigationRuleType()
-	 * @generated
-	 */
-	EReference getNavigationRuleType_DisplayName();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getIcon <em>Icon</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Icon</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getIcon()
-	 * @see #getNavigationRuleType()
-	 * @generated
-	 */
-	EReference getNavigationRuleType_Icon();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getFromViewId <em>From View Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>From View Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getFromViewId()
-	 * @see #getNavigationRuleType()
-	 * @generated
-	 */
-	EReference getNavigationRuleType_FromViewId();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getNavigationCase <em>Navigation Case</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Navigation Case</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getNavigationCase()
-	 * @see #getNavigationRuleType()
-	 * @generated
-	 */
-	EReference getNavigationRuleType_NavigationCase();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getNavigationRuleExtension <em>Navigation Rule Extension</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Navigation Rule Extension</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getNavigationRuleExtension()
-	 * @see #getNavigationRuleType()
-	 * @generated
-	 */
-    EReference getNavigationRuleType_NavigationRuleExtension();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getId()
-	 * @see #getNavigationRuleType()
-	 * @generated
-	 */
-	EAttribute getNavigationRuleType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.NullValueType <em>Null Value Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Null Value Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NullValueType
-	 * @generated
-	 */
-	EClass getNullValueType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.NullValueType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NullValueType#getId()
-	 * @see #getNullValueType()
-	 * @generated
-	 */
-	EAttribute getNullValueType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.OrderingType <em>Ordering Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Ordering Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.OrderingType
-	 * @generated
-	 */
-	EClass getOrderingType();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.OrderingType#getBefore <em>Before</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Before</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.OrderingType#getBefore()
-	 * @see #getOrderingType()
-	 * @generated
-	 */
-	EReference getOrderingType_Before();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.OrderingType#getAfter <em>After</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>After</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.OrderingType#getAfter()
-	 * @see #getOrderingType()
-	 * @generated
-	 */
-	EReference getOrderingType_After();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.OrderingOrderingType <em>Ordering Ordering Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Ordering Ordering Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.OrderingOrderingType
-	 * @generated
-	 */
-	EClass getOrderingOrderingType();
-
-				/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.OrderingOrderingType#getName <em>Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.OrderingOrderingType#getName()
-	 * @see #getOrderingOrderingType()
-	 * @generated
-	 */
-	EReference getOrderingOrderingType_Name();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.OrderingOrderingType#getOthers <em>Others</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Others</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.OrderingOrderingType#getOthers()
-	 * @see #getOrderingOrderingType()
-	 * @generated
-	 */
-	EReference getOrderingOrderingType_Others();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.OrderingOthersType <em>Ordering Others Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Ordering Others Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.OrderingOthersType
-	 * @generated
-	 */
-	EClass getOrderingOthersType();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.OrderingOthersType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.OrderingOthersType#getId()
-	 * @see #getOrderingOthersType()
-	 * @generated
-	 */
-	EAttribute getOrderingOthersType_Id();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.PartialViewContextFactoryType <em>Partial View Context Factory Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Partial View Context Factory Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PartialViewContextFactoryType
-	 * @generated
-	 */
-	EClass getPartialViewContextFactoryType();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.PartialViewContextFactoryType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PartialViewContextFactoryType#getTextContent()
-	 * @see #getPartialViewContextFactoryType()
-	 * @generated
-	 */
-	EAttribute getPartialViewContextFactoryType_TextContent();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.PartialViewContextFactoryType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PartialViewContextFactoryType#getId()
-	 * @see #getPartialViewContextFactoryType()
-	 * @generated
-	 */
-	EAttribute getPartialViewContextFactoryType_Id();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.PhaseListenerType <em>Phase Listener Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Phase Listener Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PhaseListenerType
-	 * @generated
-	 */
-	EClass getPhaseListenerType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.PhaseListenerType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PhaseListenerType#getTextContent()
-	 * @see #getPhaseListenerType()
-	 * @generated
-	 */
-	EAttribute getPhaseListenerType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.PhaseListenerType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PhaseListenerType#getId()
-	 * @see #getPhaseListenerType()
-	 * @generated
-	 */
-	EAttribute getPhaseListenerType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyClassType <em>Property Class Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Property Class Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PropertyClassType
-	 * @generated
-	 */
-	EClass getPropertyClassType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyClassType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PropertyClassType#getTextContent()
-	 * @see #getPropertyClassType()
-	 * @generated
-	 */
-	EAttribute getPropertyClassType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyClassType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PropertyClassType#getId()
-	 * @see #getPropertyClassType()
-	 * @generated
-	 */
-	EAttribute getPropertyClassType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyExtensionType <em>Property Extension Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Property Extension Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PropertyExtensionType
-	 * @generated
-	 */
-	EClass getPropertyExtensionType();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyNameType <em>Property Name Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Property Name Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PropertyNameType
-	 * @generated
-	 */
-	EClass getPropertyNameType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyNameType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PropertyNameType#getTextContent()
-	 * @see #getPropertyNameType()
-	 * @generated
-	 */
-	EAttribute getPropertyNameType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyNameType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PropertyNameType#getId()
-	 * @see #getPropertyNameType()
-	 * @generated
-	 */
-	EAttribute getPropertyNameType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyResolverType <em>Property Resolver Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Property Resolver Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PropertyResolverType
-	 * @generated
-	 */
-	EClass getPropertyResolverType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyResolverType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PropertyResolverType#getTextContent()
-	 * @see #getPropertyResolverType()
-	 * @generated
-	 */
-	EAttribute getPropertyResolverType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyResolverType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PropertyResolverType#getId()
-	 * @see #getPropertyResolverType()
-	 * @generated
-	 */
-	EAttribute getPropertyResolverType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType <em>Property Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Property Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PropertyType
-	 * @generated
-	 */
-	EClass getPropertyType();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getDescription <em>Description</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Description</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getDescription()
-	 * @see #getPropertyType()
-	 * @generated
-	 */
-	EReference getPropertyType_Description();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getDisplayName <em>Display Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Display Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getDisplayName()
-	 * @see #getPropertyType()
-	 * @generated
-	 */
-	EReference getPropertyType_DisplayName();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getIcon <em>Icon</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Icon</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getIcon()
-	 * @see #getPropertyType()
-	 * @generated
-	 */
-	EReference getPropertyType_Icon();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getPropertyName <em>Property Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Property Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getPropertyName()
-	 * @see #getPropertyType()
-	 * @generated
-	 */
-	EReference getPropertyType_PropertyName();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getPropertyClass <em>Property Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Property Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getPropertyClass()
-	 * @see #getPropertyType()
-	 * @generated
-	 */
-	EReference getPropertyType_PropertyClass();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getDefaultValue <em>Default Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Default Value</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getDefaultValue()
-	 * @see #getPropertyType()
-	 * @generated
-	 */
-	EReference getPropertyType_DefaultValue();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getSuggestedValue <em>Suggested Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Suggested Value</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getSuggestedValue()
-	 * @see #getPropertyType()
-	 * @generated
-	 */
-	EReference getPropertyType_SuggestedValue();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getPropertyExtension <em>Property Extension</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Property Extension</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getPropertyExtension()
-	 * @see #getPropertyType()
-	 * @generated
-	 */
-	EReference getPropertyType_PropertyExtension();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getId()
-	 * @see #getPropertyType()
-	 * @generated
-	 */
-	EAttribute getPropertyType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.RedirectType <em>Redirect Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Redirect Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RedirectType
-	 * @generated
-	 */
-	EClass getRedirectType();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.RedirectType#getViewParam <em>View Param</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>View Param</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RedirectType#getViewParam()
-	 * @see #getRedirectType()
-	 * @generated
-	 */
-	EReference getRedirectType_ViewParam();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.RedirectType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RedirectType#getId()
-	 * @see #getRedirectType()
-	 * @generated
-	 */
-	EAttribute getRedirectType_Id();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.RedirectType#isIncludeViewParams <em>Include View Params</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Include View Params</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RedirectType#isIncludeViewParams()
-	 * @see #getRedirectType()
-	 * @generated
-	 */
-	EAttribute getRedirectType_IncludeViewParams();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType <em>Redirect View Param Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Redirect View Param Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType
-	 * @generated
-	 */
-	EClass getRedirectViewParamType();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType#getName <em>Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType#getName()
-	 * @see #getRedirectViewParamType()
-	 * @generated
-	 */
-	EReference getRedirectViewParamType_Name();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType#getValue <em>Value</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Value</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType#getValue()
-	 * @see #getRedirectViewParamType()
-	 * @generated
-	 */
-	EReference getRedirectViewParamType_Value();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType#getId()
-	 * @see #getRedirectViewParamType()
-	 * @generated
-	 */
-	EAttribute getRedirectViewParamType_Id();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanClassType <em>Referenced Bean Class Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Referenced Bean Class Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanClassType
-	 * @generated
-	 */
-	EClass getReferencedBeanClassType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanClassType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanClassType#getTextContent()
-	 * @see #getReferencedBeanClassType()
-	 * @generated
-	 */
-	EAttribute getReferencedBeanClassType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanClassType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanClassType#getId()
-	 * @see #getReferencedBeanClassType()
-	 * @generated
-	 */
-	EAttribute getReferencedBeanClassType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanNameType <em>Referenced Bean Name Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Referenced Bean Name Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanNameType
-	 * @generated
-	 */
-	EClass getReferencedBeanNameType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanNameType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanNameType#getTextContent()
-	 * @see #getReferencedBeanNameType()
-	 * @generated
-	 */
-	EAttribute getReferencedBeanNameType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanNameType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanNameType#getId()
-	 * @see #getReferencedBeanNameType()
-	 * @generated
-	 */
-	EAttribute getReferencedBeanNameType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType <em>Referenced Bean Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Referenced Bean Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType
-	 * @generated
-	 */
-	EClass getReferencedBeanType();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType#getDescription <em>Description</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Description</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType#getDescription()
-	 * @see #getReferencedBeanType()
-	 * @generated
-	 */
-	EReference getReferencedBeanType_Description();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType#getDisplayName <em>Display Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Display Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType#getDisplayName()
-	 * @see #getReferencedBeanType()
-	 * @generated
-	 */
-	EReference getReferencedBeanType_DisplayName();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType#getIcon <em>Icon</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Icon</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType#getIcon()
-	 * @see #getReferencedBeanType()
-	 * @generated
-	 */
-	EReference getReferencedBeanType_Icon();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType#getReferencedBeanName <em>Referenced Bean Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Referenced Bean Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType#getReferencedBeanName()
-	 * @see #getReferencedBeanType()
-	 * @generated
-	 */
-	EReference getReferencedBeanType_ReferencedBeanName();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType#getReferencedBeanClass <em>Referenced Bean Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Referenced Bean Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType#getReferencedBeanClass()
-	 * @see #getReferencedBeanType()
-	 * @generated
-	 */
-	EReference getReferencedBeanType_ReferencedBeanClass();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType#getId()
-	 * @see #getReferencedBeanType()
-	 * @generated
-	 */
-	EAttribute getReferencedBeanType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererClassType <em>Renderer Class Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Renderer Class Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RendererClassType
-	 * @generated
-	 */
-	EClass getRendererClassType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererClassType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RendererClassType#getTextContent()
-	 * @see #getRendererClassType()
-	 * @generated
-	 */
-	EAttribute getRendererClassType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererClassType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RendererClassType#getId()
-	 * @see #getRendererClassType()
-	 * @generated
-	 */
-	EAttribute getRendererClassType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererExtensionType <em>Renderer Extension Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Renderer Extension Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RendererExtensionType
-	 * @generated
-	 */
-	EClass getRendererExtensionType();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType <em>Renderer Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Renderer Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RendererType
-	 * @generated
-	 */
-	EClass getRendererType();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getDescription <em>Description</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Description</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RendererType#getDescription()
-	 * @see #getRendererType()
-	 * @generated
-	 */
-	EReference getRendererType_Description();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getDisplayName <em>Display Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Display Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RendererType#getDisplayName()
-	 * @see #getRendererType()
-	 * @generated
-	 */
-	EReference getRendererType_DisplayName();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getIcon <em>Icon</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Icon</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RendererType#getIcon()
-	 * @see #getRendererType()
-	 * @generated
-	 */
-	EReference getRendererType_Icon();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getComponentFamily <em>Component Family</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Component Family</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RendererType#getComponentFamily()
-	 * @see #getRendererType()
-	 * @generated
-	 */
-	EReference getRendererType_ComponentFamily();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getRendererType <em>Renderer Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Renderer Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RendererType#getRendererType()
-	 * @see #getRendererType()
-	 * @generated
-	 */
-	EReference getRendererType_RendererType();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getRendererClass <em>Renderer Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Renderer Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RendererType#getRendererClass()
-	 * @see #getRendererType()
-	 * @generated
-	 */
-	EReference getRendererType_RendererClass();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getFacet <em>Facet</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Facet</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RendererType#getFacet()
-	 * @see #getRendererType()
-	 * @generated
-	 */
-	EReference getRendererType_Facet();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getAttribute <em>Attribute</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Attribute</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RendererType#getAttribute()
-	 * @see #getRendererType()
-	 * @generated
-	 */
-	EReference getRendererType_Attribute();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getRendererExtension <em>Renderer Extension</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Renderer Extension</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RendererType#getRendererExtension()
-	 * @see #getRendererType()
-	 * @generated
-	 */
-	EReference getRendererType_RendererExtension();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RendererType#getId()
-	 * @see #getRendererType()
-	 * @generated
-	 */
-	EAttribute getRendererType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererTypeType <em>Renderer Type Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Renderer Type Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RendererTypeType
-	 * @generated
-	 */
-	EClass getRendererTypeType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererTypeType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RendererTypeType#getTextContent()
-	 * @see #getRendererTypeType()
-	 * @generated
-	 */
-	EAttribute getRendererTypeType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererTypeType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RendererTypeType#getId()
-	 * @see #getRendererTypeType()
-	 * @generated
-	 */
-	EAttribute getRendererTypeType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitClassType <em>Render Kit Class Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Render Kit Class Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RenderKitClassType
-	 * @generated
-	 */
-	EClass getRenderKitClassType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitClassType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RenderKitClassType#getTextContent()
-	 * @see #getRenderKitClassType()
-	 * @generated
-	 */
-	EAttribute getRenderKitClassType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitClassType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RenderKitClassType#getId()
-	 * @see #getRenderKitClassType()
-	 * @generated
-	 */
-	EAttribute getRenderKitClassType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitFactoryType <em>Render Kit Factory Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Render Kit Factory Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RenderKitFactoryType
-	 * @generated
-	 */
-	EClass getRenderKitFactoryType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitFactoryType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RenderKitFactoryType#getTextContent()
-	 * @see #getRenderKitFactoryType()
-	 * @generated
-	 */
-	EAttribute getRenderKitFactoryType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitFactoryType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RenderKitFactoryType#getId()
-	 * @see #getRenderKitFactoryType()
-	 * @generated
-	 */
-	EAttribute getRenderKitFactoryType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitIdType <em>Render Kit Id Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Render Kit Id Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RenderKitIdType
-	 * @generated
-	 */
-	EClass getRenderKitIdType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitIdType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RenderKitIdType#getTextContent()
-	 * @see #getRenderKitIdType()
-	 * @generated
-	 */
-	EAttribute getRenderKitIdType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitIdType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RenderKitIdType#getId()
-	 * @see #getRenderKitIdType()
-	 * @generated
-	 */
-	EAttribute getRenderKitIdType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType <em>Render Kit Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Render Kit Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RenderKitType
-	 * @generated
-	 */
-	EClass getRenderKitType();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getDescription <em>Description</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Description</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getDescription()
-	 * @see #getRenderKitType()
-	 * @generated
-	 */
-	EReference getRenderKitType_Description();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getDisplayName <em>Display Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Display Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getDisplayName()
-	 * @see #getRenderKitType()
-	 * @generated
-	 */
-	EReference getRenderKitType_DisplayName();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getIcon <em>Icon</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Icon</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getIcon()
-	 * @see #getRenderKitType()
-	 * @generated
-	 */
-	EReference getRenderKitType_Icon();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getRenderKitId <em>Render Kit Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Render Kit Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getRenderKitId()
-	 * @see #getRenderKitType()
-	 * @generated
-	 */
-	EReference getRenderKitType_RenderKitId();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getRenderKitClass <em>Render Kit Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Render Kit Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getRenderKitClass()
-	 * @see #getRenderKitType()
-	 * @generated
-	 */
-	EReference getRenderKitType_RenderKitClass();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getRenderer <em>Renderer</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Renderer</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getRenderer()
-	 * @see #getRenderKitType()
-	 * @generated
-	 */
-	EReference getRenderKitType_Renderer();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getClientBehaviorRenderer <em>Client Behavior Renderer</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Client Behavior Renderer</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getClientBehaviorRenderer()
-	 * @see #getRenderKitType()
-	 * @generated
-	 */
-	EReference getRenderKitType_ClientBehaviorRenderer();
-
-				/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getRenderKitExtension <em>Render Kit Extension</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Render Kit Extension</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getRenderKitExtension()
-	 * @see #getRenderKitType()
-	 * @generated
-	 */
-    EReference getRenderKitType_RenderKitExtension();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getId()
-	 * @see #getRenderKitType()
-	 * @generated
-	 */
-	EAttribute getRenderKitType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.SmallIconType <em>Small Icon Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Small Icon Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SmallIconType
-	 * @generated
-	 */
-	EClass getSmallIconType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.SmallIconType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SmallIconType#getTextContent()
-	 * @see #getSmallIconType()
-	 * @generated
-	 */
-	EAttribute getSmallIconType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.SmallIconType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SmallIconType#getId()
-	 * @see #getSmallIconType()
-	 * @generated
-	 */
-	EAttribute getSmallIconType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.SourceClassType <em>Source Class Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Source Class Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SourceClassType
-	 * @generated
-	 */
-	EClass getSourceClassType();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.SourceClassType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SourceClassType#getTextContent()
-	 * @see #getSourceClassType()
-	 * @generated
-	 */
-	EAttribute getSourceClassType_TextContent();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.SourceClassType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SourceClassType#getId()
-	 * @see #getSourceClassType()
-	 * @generated
-	 */
-	EAttribute getSourceClassType_Id();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.StateManagerType <em>State Manager Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>State Manager Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.StateManagerType
-	 * @generated
-	 */
-	EClass getStateManagerType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.StateManagerType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.StateManagerType#getTextContent()
-	 * @see #getStateManagerType()
-	 * @generated
-	 */
-	EAttribute getStateManagerType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.StateManagerType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.StateManagerType#getId()
-	 * @see #getStateManagerType()
-	 * @generated
-	 */
-	EAttribute getStateManagerType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.SuggestedValueType <em>Suggested Value Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Suggested Value Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SuggestedValueType
-	 * @generated
-	 */
-	EClass getSuggestedValueType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.SuggestedValueType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SuggestedValueType#getTextContent()
-	 * @see #getSuggestedValueType()
-	 * @generated
-	 */
-	EAttribute getSuggestedValueType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.SuggestedValueType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SuggestedValueType#getId()
-	 * @see #getSuggestedValueType()
-	 * @generated
-	 */
-	EAttribute getSuggestedValueType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.SupportedLocaleType <em>Supported Locale Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Supported Locale Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SupportedLocaleType
-	 * @generated
-	 */
-	EClass getSupportedLocaleType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.SupportedLocaleType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SupportedLocaleType#getTextContent()
-	 * @see #getSupportedLocaleType()
-	 * @generated
-	 */
-	EAttribute getSupportedLocaleType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.SupportedLocaleType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SupportedLocaleType#getId()
-	 * @see #getSupportedLocaleType()
-	 * @generated
-	 */
-	EAttribute getSupportedLocaleType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventClassType <em>System Event Class Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>System Event Class Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SystemEventClassType
-	 * @generated
-	 */
-	EClass getSystemEventClassType();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventClassType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SystemEventClassType#getTextContent()
-	 * @see #getSystemEventClassType()
-	 * @generated
-	 */
-	EAttribute getSystemEventClassType_TextContent();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventClassType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SystemEventClassType#getId()
-	 * @see #getSystemEventClassType()
-	 * @generated
-	 */
-	EAttribute getSystemEventClassType_Id();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerClassType <em>System Event Listener Class Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>System Event Listener Class Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerClassType
-	 * @generated
-	 */
-	EClass getSystemEventListenerClassType();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerClassType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerClassType#getTextContent()
-	 * @see #getSystemEventListenerClassType()
-	 * @generated
-	 */
-	EAttribute getSystemEventListenerClassType_TextContent();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerClassType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerClassType#getId()
-	 * @see #getSystemEventListenerClassType()
-	 * @generated
-	 */
-	EAttribute getSystemEventListenerClassType_Id();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType <em>System Event Listener Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>System Event Listener Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType
-	 * @generated
-	 */
-	EClass getSystemEventListenerType();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType#getSystemEventListenerClass <em>System Event Listener Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>System Event Listener Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType#getSystemEventListenerClass()
-	 * @see #getSystemEventListenerType()
-	 * @generated
-	 */
-	EReference getSystemEventListenerType_SystemEventListenerClass();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType#getSystemEventClass <em>System Event Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>System Event Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType#getSystemEventClass()
-	 * @see #getSystemEventListenerType()
-	 * @generated
-	 */
-	EReference getSystemEventListenerType_SystemEventClass();
-
-				/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType#getSourceClass <em>Source Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Source Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType#getSourceClass()
-	 * @see #getSystemEventListenerType()
-	 * @generated
-	 */
-	EReference getSystemEventListenerType_SourceClass();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType#getId()
-	 * @see #getSystemEventListenerType()
-	 * @generated
-	 */
-	EAttribute getSystemEventListenerType_Id();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.TagHandlerDelegateFactoryType <em>Tag Handler Delegate Factory Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Tag Handler Delegate Factory Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.TagHandlerDelegateFactoryType
-	 * @generated
-	 */
-	EClass getTagHandlerDelegateFactoryType();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.TagHandlerDelegateFactoryType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.TagHandlerDelegateFactoryType#getTextContent()
-	 * @see #getTagHandlerDelegateFactoryType()
-	 * @generated
-	 */
-	EAttribute getTagHandlerDelegateFactoryType_TextContent();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.TagHandlerDelegateFactoryType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.TagHandlerDelegateFactoryType#getId()
-	 * @see #getTagHandlerDelegateFactoryType()
-	 * @generated
-	 */
-	EAttribute getTagHandlerDelegateFactoryType_Id();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ToViewIdType <em>To View Id Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>To View Id Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ToViewIdType
-	 * @generated
-	 */
-	EClass getToViewIdType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ToViewIdType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ToViewIdType#getTextContent()
-	 * @see #getToViewIdType()
-	 * @generated
-	 */
-	EAttribute getToViewIdType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ToViewIdType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ToViewIdType#getId()
-	 * @see #getToViewIdType()
-	 * @generated
-	 */
-	EAttribute getToViewIdType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorClassType <em>Validator Class Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Validator Class Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValidatorClassType
-	 * @generated
-	 */
-	EClass getValidatorClassType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorClassType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValidatorClassType#getTextContent()
-	 * @see #getValidatorClassType()
-	 * @generated
-	 */
-	EAttribute getValidatorClassType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorClassType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValidatorClassType#getId()
-	 * @see #getValidatorClassType()
-	 * @generated
-	 */
-	EAttribute getValidatorClassType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorIdType <em>Validator Id Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Validator Id Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValidatorIdType
-	 * @generated
-	 */
-	EClass getValidatorIdType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorIdType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValidatorIdType#getTextContent()
-	 * @see #getValidatorIdType()
-	 * @generated
-	 */
-	EAttribute getValidatorIdType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorIdType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValidatorIdType#getId()
-	 * @see #getValidatorIdType()
-	 * @generated
-	 */
-	EAttribute getValidatorIdType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType <em>Validator Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Validator Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValidatorType
-	 * @generated
-	 */
-	EClass getValidatorType();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getDescription <em>Description</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Description</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getDescription()
-	 * @see #getValidatorType()
-	 * @generated
-	 */
-	EReference getValidatorType_Description();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getDisplayName <em>Display Name</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Display Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getDisplayName()
-	 * @see #getValidatorType()
-	 * @generated
-	 */
-	EReference getValidatorType_DisplayName();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getIcon <em>Icon</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Icon</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getIcon()
-	 * @see #getValidatorType()
-	 * @generated
-	 */
-	EReference getValidatorType_Icon();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getValidatorId <em>Validator Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Validator Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getValidatorId()
-	 * @see #getValidatorType()
-	 * @generated
-	 */
-	EReference getValidatorType_ValidatorId();
-
-    /**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getValidatorClass <em>Validator Class</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Validator Class</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getValidatorClass()
-	 * @see #getValidatorType()
-	 * @generated
-	 */
-	EReference getValidatorType_ValidatorClass();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getAttribute <em>Attribute</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Attribute</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getAttribute()
-	 * @see #getValidatorType()
-	 * @generated
-	 */
-	EReference getValidatorType_Attribute();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getProperty <em>Property</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Property</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getProperty()
-	 * @see #getValidatorType()
-	 * @generated
-	 */
-	EReference getValidatorType_Property();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getValidatorExtension <em>Validator Extension</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Validator Extension</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getValidatorExtension()
-	 * @see #getValidatorType()
-	 * @generated
-	 */
-    EReference getValidatorType_ValidatorExtension();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getId()
-	 * @see #getValidatorType()
-	 * @generated
-	 */
-	EAttribute getValidatorType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ValueClassType <em>Value Class Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Value Class Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValueClassType
-	 * @generated
-	 */
-	EClass getValueClassType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ValueClassType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValueClassType#getTextContent()
-	 * @see #getValueClassType()
-	 * @generated
-	 */
-	EAttribute getValueClassType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ValueClassType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValueClassType#getId()
-	 * @see #getValueClassType()
-	 * @generated
-	 */
-	EAttribute getValueClassType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ValueType <em>Value Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Value Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValueType
-	 * @generated
-	 */
-	EClass getValueType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ValueType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValueType#getTextContent()
-	 * @see #getValueType()
-	 * @generated
-	 */
-	EAttribute getValueType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ValueType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValueType#getId()
-	 * @see #getValueType()
-	 * @generated
-	 */
-	EAttribute getValueType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.VariableResolverType <em>Variable Resolver Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Variable Resolver Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.VariableResolverType
-	 * @generated
-	 */
-	EClass getVariableResolverType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.VariableResolverType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.VariableResolverType#getTextContent()
-	 * @see #getVariableResolverType()
-	 * @generated
-	 */
-	EAttribute getVariableResolverType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.VariableResolverType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.VariableResolverType#getId()
-	 * @see #getVariableResolverType()
-	 * @generated
-	 */
-	EAttribute getVariableResolverType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ViewHandlerType <em>View Handler Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>View Handler Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ViewHandlerType
-	 * @generated
-	 */
-	EClass getViewHandlerType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ViewHandlerType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ViewHandlerType#getTextContent()
-	 * @see #getViewHandlerType()
-	 * @generated
-	 */
-	EAttribute getViewHandlerType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ViewHandlerType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ViewHandlerType#getId()
-	 * @see #getViewHandlerType()
-	 * @generated
-	 */
-	EAttribute getViewHandlerType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType <em>Resource Bundle Type</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Resource Bundle Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType
-	 * @generated
-	 */
-    EClass getResourceBundleType();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType#getDescription <em>Description</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Description</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType#getDescription()
-	 * @see #getResourceBundleType()
-	 * @generated
-	 */
-    EReference getResourceBundleType_Description();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType#getDisplayName <em>Display Name</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Display Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType#getDisplayName()
-	 * @see #getResourceBundleType()
-	 * @generated
-	 */
-    EReference getResourceBundleType_DisplayName();
-
-    /**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType#getIcon <em>Icon</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Icon</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType#getIcon()
-	 * @see #getResourceBundleType()
-	 * @generated
-	 */
-    EReference getResourceBundleType_Icon();
-
-    /**
-	 * Returns the meta object for the reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType#getBaseName <em>Base Name</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Base Name</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType#getBaseName()
-	 * @see #getResourceBundleType()
-	 * @generated
-	 */
-    EReference getResourceBundleType_BaseName();
-
-    /**
-	 * Returns the meta object for the reference '{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType#getVar <em>Var</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Var</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType#getVar()
-	 * @see #getResourceBundleType()
-	 * @generated
-	 */
-    EReference getResourceBundleType_Var();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType#getId()
-	 * @see #getResourceBundleType()
-	 * @generated
-	 */
-    EAttribute getResourceBundleType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.BaseNameType <em>Base Name Type</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Base Name Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.BaseNameType
-	 * @generated
-	 */
-    EClass getBaseNameType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.BaseNameType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.BaseNameType#getTextContent()
-	 * @see #getBaseNameType()
-	 * @generated
-	 */
-    EAttribute getBaseNameType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.BaseNameType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.BaseNameType#getId()
-	 * @see #getBaseNameType()
-	 * @generated
-	 */
-    EAttribute getBaseNameType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.VarType <em>Var Type</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Var Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.VarType
-	 * @generated
-	 */
-    EClass getVarType();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.VarType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.VarType#getTextContent()
-	 * @see #getVarType()
-	 * @generated
-	 */
-    EAttribute getVarType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.VarType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.VarType#getId()
-	 * @see #getVarType()
-	 * @generated
-	 */
-    EAttribute getVarType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ViewDeclarationLanguageFactoryType <em>View Declaration Language Factory Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>View Declaration Language Factory Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ViewDeclarationLanguageFactoryType
-	 * @generated
-	 */
-	EClass getViewDeclarationLanguageFactoryType();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ViewDeclarationLanguageFactoryType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ViewDeclarationLanguageFactoryType#getTextContent()
-	 * @see #getViewDeclarationLanguageFactoryType()
-	 * @generated
-	 */
-	EAttribute getViewDeclarationLanguageFactoryType_TextContent();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ViewDeclarationLanguageFactoryType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ViewDeclarationLanguageFactoryType#getId()
-	 * @see #getViewDeclarationLanguageFactoryType()
-	 * @generated
-	 */
-	EAttribute getViewDeclarationLanguageFactoryType_Id();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.VisitContextFactoryType <em>Visit Context Factory Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Visit Context Factory Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.VisitContextFactoryType
-	 * @generated
-	 */
-	EClass getVisitContextFactoryType();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.VisitContextFactoryType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.VisitContextFactoryType#getTextContent()
-	 * @see #getVisitContextFactoryType()
-	 * @generated
-	 */
-	EAttribute getVisitContextFactoryType_TextContent();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.VisitContextFactoryType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.VisitContextFactoryType#getId()
-	 * @see #getVisitContextFactoryType()
-	 * @generated
-	 */
-	EAttribute getVisitContextFactoryType_Id();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitExtensionType <em>Render Kit Extension Type</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Render Kit Extension Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.RenderKitExtensionType
-	 * @generated
-	 */
-    EClass getRenderKitExtensionType();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceHandlerType <em>Resource Handler Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Resource Handler Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ResourceHandlerType
-	 * @generated
-	 */
-	EClass getResourceHandlerType();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceHandlerType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ResourceHandlerType#getTextContent()
-	 * @see #getResourceHandlerType()
-	 * @generated
-	 */
-	EAttribute getResourceHandlerType_TextContent();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceHandlerType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ResourceHandlerType#getId()
-	 * @see #getResourceHandlerType()
-	 * @generated
-	 */
-	EAttribute getResourceHandlerType_Id();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleExtensionType <em>Navigation Rule Extension Type</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Navigation Rule Extension Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleExtensionType
-	 * @generated
-	 */
-    EClass getNavigationRuleExtensionType();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorExtensionType <em>Validator Extension Type</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Validator Extension Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ValidatorExtensionType
-	 * @generated
-	 */
-    EClass getValidatorExtensionType();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigExtensionType <em>Extension Type</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Extension Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigExtensionType
-	 * @generated
-	 */
-    EClass getFacesConfigExtensionType();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryExtensionType <em>Factory Extension Type</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Factory Extension Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FactoryExtensionType
-	 * @generated
-	 */
-    EClass getFactoryExtensionType();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleExtensionType <em>Lifecycle Extension Type</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Lifecycle Extension Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.LifecycleExtensionType
-	 * @generated
-	 */
-    EClass getLifecycleExtensionType();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanExtensionType <em>Managed Bean Extension Type</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Managed Bean Extension Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanExtensionType
-	 * @generated
-	 */
-    EClass getManagedBeanExtensionType();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterExtensionType <em>Converter Extension Type</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Converter Extension Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ConverterExtensionType
-	 * @generated
-	 */
-    EClass getConverterExtensionType();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ExtensionType <em>Extension Type</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Extension Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ExtensionType
-	 * @generated
-	 */
-    EClass getExtensionType();
-
-    /**
-	 * Returns the meta object for the reference list '{@link org.eclipse.jst.jsf.facesconfig.emf.ExtensionType#getChildNodes <em>Child Nodes</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the reference list '<em>Child Nodes</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ExtensionType#getChildNodes()
-	 * @see #getExtensionType()
-	 * @generated
-	 */
-    EReference getExtensionType_ChildNodes();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ExtensionType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ExtensionType#getTextContent()
-	 * @see #getExtensionType()
-	 * @generated
-	 */
-    EAttribute getExtensionType_TextContent();
-
-    /**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ExtensionType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ExtensionType#getId()
-	 * @see #getExtensionType()
-	 * @generated
-	 */
-    EAttribute getExtensionType_Id();
-
-    /**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ExternalContextFactoryType <em>External Context Factory Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>External Context Factory Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ExternalContextFactoryType
-	 * @generated
-	 */
-	EClass getExternalContextFactoryType();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ExternalContextFactoryType#getTextContent <em>Text Content</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Text Content</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ExternalContextFactoryType#getTextContent()
-	 * @see #getExternalContextFactoryType()
-	 * @generated
-	 */
-	EAttribute getExternalContextFactoryType_TextContent();
-
-				/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facesconfig.emf.ExternalContextFactoryType#getId <em>Id</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Id</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ExternalContextFactoryType#getId()
-	 * @see #getExternalContextFactoryType()
-	 * @generated
-	 */
-	EAttribute getExternalContextFactoryType_Id();
-
-				/**
-	 * Returns the meta object for class '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationExtensionType <em>Application Extension Type</em>}'.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Application Extension Type</em>'.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.ApplicationExtensionType
-	 * @generated
-	 */
-    EClass getApplicationExtensionType();
-
-    /**
-	 * 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
-	 */
-	FacesConfigFactory getFacesConfigFactory();
-
-    /**
-	 * <!-- 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 enum,</li>
-     *   <li>and each data type</li>
-     * </ul>
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-//    @SuppressWarnings("hiding")
-    interface Literals  {
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AbsoluteOrderingTypeImpl <em>Absolute Ordering Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.AbsoluteOrderingTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getAbsoluteOrderingType()
-		 * @generated
-		 */
-		EClass ABSOLUTE_ORDERING_TYPE = eINSTANCE.getAbsoluteOrderingType();
-
-					/**
-		 * The meta object literal for the '<em><b>Name</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference ABSOLUTE_ORDERING_TYPE__NAME = eINSTANCE.getAbsoluteOrderingType_Name();
-
-					/**
-		 * The meta object literal for the '<em><b>Others</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference ABSOLUTE_ORDERING_TYPE__OTHERS = eINSTANCE.getAbsoluteOrderingType_Others();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ActionListenerTypeImpl <em>Action Listener Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ActionListenerTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getActionListenerType()
-		 * @generated
-		 */
-        EClass ACTION_LISTENER_TYPE = eINSTANCE.getActionListenerType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute ACTION_LISTENER_TYPE__TEXT_CONTENT = eINSTANCE.getActionListenerType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute ACTION_LISTENER_TYPE__ID = eINSTANCE.getActionListenerType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationFactoryTypeImpl <em>Application Factory Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationFactoryTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getApplicationFactoryType()
-		 * @generated
-		 */
-        EClass APPLICATION_FACTORY_TYPE = eINSTANCE.getApplicationFactoryType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute APPLICATION_FACTORY_TYPE__TEXT_CONTENT = eINSTANCE.getApplicationFactoryType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute APPLICATION_FACTORY_TYPE__ID = eINSTANCE.getApplicationFactoryType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl <em>Application Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getApplicationType()
-		 * @generated
-		 */
-        EClass APPLICATION_TYPE = eINSTANCE.getApplicationType();
-
-        /**
-		 * The meta object literal for the '<em><b>Action Listener</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference APPLICATION_TYPE__ACTION_LISTENER = eINSTANCE.getApplicationType_ActionListener();
-
-        /**
-		 * The meta object literal for the '<em><b>Default Render Kit Id</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference APPLICATION_TYPE__DEFAULT_RENDER_KIT_ID = eINSTANCE.getApplicationType_DefaultRenderKitId();
-
-        /**
-		 * The meta object literal for the '<em><b>Message Bundle</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference APPLICATION_TYPE__MESSAGE_BUNDLE = eINSTANCE.getApplicationType_MessageBundle();
-
-        /**
-		 * The meta object literal for the '<em><b>Navigation Handler</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference APPLICATION_TYPE__NAVIGATION_HANDLER = eINSTANCE.getApplicationType_NavigationHandler();
-
-        /**
-		 * The meta object literal for the '<em><b>View Handler</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference APPLICATION_TYPE__VIEW_HANDLER = eINSTANCE.getApplicationType_ViewHandler();
-
-        /**
-		 * The meta object literal for the '<em><b>State Manager</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference APPLICATION_TYPE__STATE_MANAGER = eINSTANCE.getApplicationType_StateManager();
-
-        /**
-		 * The meta object literal for the '<em><b>Property Resolver</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference APPLICATION_TYPE__PROPERTY_RESOLVER = eINSTANCE.getApplicationType_PropertyResolver();
-
-        /**
-		 * The meta object literal for the '<em><b>Variable Resolver</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference APPLICATION_TYPE__VARIABLE_RESOLVER = eINSTANCE.getApplicationType_VariableResolver();
-
-        /**
-		 * The meta object literal for the '<em><b>Resource Handler</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference APPLICATION_TYPE__RESOURCE_HANDLER = eINSTANCE.getApplicationType_ResourceHandler();
-
-								/**
-		 * The meta object literal for the '<em><b>System Event Listener</b></em>' reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference APPLICATION_TYPE__SYSTEM_EVENT_LISTENER = eINSTANCE.getApplicationType_SystemEventListener();
-
-								/**
-		 * The meta object literal for the '<em><b>Locale Config</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference APPLICATION_TYPE__LOCALE_CONFIG = eINSTANCE.getApplicationType_LocaleConfig();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute APPLICATION_TYPE__ID = eINSTANCE.getApplicationType_Id();
-
-        /**
-		 * The meta object literal for the '<em><b>EL Resolver</b></em>' reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference APPLICATION_TYPE__EL_RESOLVER = eINSTANCE.getApplicationType_ELResolver();
-
-        /**
-		 * The meta object literal for the '<em><b>Resource Bundle</b></em>' reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference APPLICATION_TYPE__RESOURCE_BUNDLE = eINSTANCE.getApplicationType_ResourceBundle();
-
-        /**
-		 * The meta object literal for the '<em><b>Application Extension</b></em>' reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference APPLICATION_TYPE__APPLICATION_EXTENSION = eINSTANCE.getApplicationType_ApplicationExtension();
-
-        /**
-		 * The meta object literal for the '<em><b>Default Validators</b></em>' reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference APPLICATION_TYPE__DEFAULT_VALIDATORS = eINSTANCE.getApplicationType_DefaultValidators();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeClassTypeImpl <em>Attribute Class Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeClassTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getAttributeClassType()
-		 * @generated
-		 */
-        EClass ATTRIBUTE_CLASS_TYPE = eINSTANCE.getAttributeClassType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute ATTRIBUTE_CLASS_TYPE__TEXT_CONTENT = eINSTANCE.getAttributeClassType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute ATTRIBUTE_CLASS_TYPE__ID = eINSTANCE.getAttributeClassType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeExtensionTypeImpl <em>Attribute Extension Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeExtensionTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getAttributeExtensionType()
-		 * @generated
-		 */
-        EClass ATTRIBUTE_EXTENSION_TYPE = eINSTANCE.getAttributeExtensionType();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeNameTypeImpl <em>Attribute Name Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeNameTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getAttributeNameType()
-		 * @generated
-		 */
-        EClass ATTRIBUTE_NAME_TYPE = eINSTANCE.getAttributeNameType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute ATTRIBUTE_NAME_TYPE__TEXT_CONTENT = eINSTANCE.getAttributeNameType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute ATTRIBUTE_NAME_TYPE__ID = eINSTANCE.getAttributeNameType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeTypeImpl <em>Attribute Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getAttributeType()
-		 * @generated
-		 */
-        EClass ATTRIBUTE_TYPE = eINSTANCE.getAttributeType();
-
-        /**
-		 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference ATTRIBUTE_TYPE__DESCRIPTION = eINSTANCE.getAttributeType_Description();
-
-        /**
-		 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference ATTRIBUTE_TYPE__DISPLAY_NAME = eINSTANCE.getAttributeType_DisplayName();
-
-        /**
-		 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference ATTRIBUTE_TYPE__ICON = eINSTANCE.getAttributeType_Icon();
-
-        /**
-		 * The meta object literal for the '<em><b>Attribute Name</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference ATTRIBUTE_TYPE__ATTRIBUTE_NAME = eINSTANCE.getAttributeType_AttributeName();
-
-        /**
-		 * The meta object literal for the '<em><b>Attribute Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference ATTRIBUTE_TYPE__ATTRIBUTE_CLASS = eINSTANCE.getAttributeType_AttributeClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Default Value</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference ATTRIBUTE_TYPE__DEFAULT_VALUE = eINSTANCE.getAttributeType_DefaultValue();
-
-        /**
-		 * The meta object literal for the '<em><b>Suggested Value</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference ATTRIBUTE_TYPE__SUGGESTED_VALUE = eINSTANCE.getAttributeType_SuggestedValue();
-
-        /**
-		 * The meta object literal for the '<em><b>Attribute Extension</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference ATTRIBUTE_TYPE__ATTRIBUTE_EXTENSION = eINSTANCE.getAttributeType_AttributeExtension();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute ATTRIBUTE_TYPE__ID = eINSTANCE.getAttributeType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorClassTypeImpl <em>Behavior Class Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorClassTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getBehaviorClassType()
-		 * @generated
-		 */
-		EClass BEHAVIOR_CLASS_TYPE = eINSTANCE.getBehaviorClassType();
-
-								/**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute BEHAVIOR_CLASS_TYPE__TEXT_CONTENT = eINSTANCE.getBehaviorClassType_TextContent();
-
-								/**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute BEHAVIOR_CLASS_TYPE__ID = eINSTANCE.getBehaviorClassType_Id();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorIdTypeImpl <em>Behavior Id Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorIdTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getBehaviorIdType()
-		 * @generated
-		 */
-		EClass BEHAVIOR_ID_TYPE = eINSTANCE.getBehaviorIdType();
-
-								/**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute BEHAVIOR_ID_TYPE__TEXT_CONTENT = eINSTANCE.getBehaviorIdType_TextContent();
-
-								/**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute BEHAVIOR_ID_TYPE__ID = eINSTANCE.getBehaviorIdType_Id();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorTypeImpl <em>Behavior Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getBehaviorType()
-		 * @generated
-		 */
-		EClass BEHAVIOR_TYPE = eINSTANCE.getBehaviorType();
-
-								/**
-		 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference BEHAVIOR_TYPE__DESCRIPTION = eINSTANCE.getBehaviorType_Description();
-
-								/**
-		 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference BEHAVIOR_TYPE__DISPLAY_NAME = eINSTANCE.getBehaviorType_DisplayName();
-
-								/**
-		 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference BEHAVIOR_TYPE__ICON = eINSTANCE.getBehaviorType_Icon();
-
-								/**
-		 * The meta object literal for the '<em><b>Behavior Id</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference BEHAVIOR_TYPE__BEHAVIOR_ID = eINSTANCE.getBehaviorType_BehaviorId();
-
-								/**
-		 * The meta object literal for the '<em><b>Behavior Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference BEHAVIOR_TYPE__BEHAVIOR_CLASS = eINSTANCE.getBehaviorType_BehaviorClass();
-
-								/**
-		 * The meta object literal for the '<em><b>Attribute</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference BEHAVIOR_TYPE__ATTRIBUTE = eINSTANCE.getBehaviorType_Attribute();
-
-								/**
-		 * The meta object literal for the '<em><b>Property</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference BEHAVIOR_TYPE__PROPERTY = eINSTANCE.getBehaviorType_Property();
-
-								/**
-		 * The meta object literal for the '<em><b>Behavior Extension</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference BEHAVIOR_TYPE__BEHAVIOR_EXTENSION = eINSTANCE.getBehaviorType_BehaviorExtension();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorExtensionTypeImpl <em>Behavior Extension Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorExtensionTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getBehaviorExtensionType()
-		 * @generated
-		 */
-		EClass BEHAVIOR_EXTENSION_TYPE = eINSTANCE.getBehaviorExtensionType();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ClientBehaviorRendererClassTypeImpl <em>Client Behavior Renderer Class Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ClientBehaviorRendererClassTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getClientBehaviorRendererClassType()
-		 * @generated
-		 */
-		EClass CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE = eINSTANCE.getClientBehaviorRendererClassType();
-
-								/**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE__TEXT_CONTENT = eINSTANCE.getClientBehaviorRendererClassType_TextContent();
-
-								/**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE__ID = eINSTANCE.getClientBehaviorRendererClassType_Id();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ClientBehaviorRendererTypeImpl <em>Client Behavior Renderer Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ClientBehaviorRendererTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getClientBehaviorRendererType()
-		 * @generated
-		 */
-		EClass CLIENT_BEHAVIOR_RENDERER_TYPE = eINSTANCE.getClientBehaviorRendererType();
-
-								/**
-		 * The meta object literal for the '<em><b>Client Behavior Renderer Type</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_TYPE = eINSTANCE.getClientBehaviorRendererType_ClientBehaviorRendererType();
-
-								/**
-		 * The meta object literal for the '<em><b>Client Behavior Renderer Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_CLASS = eINSTANCE.getClientBehaviorRendererType_ClientBehaviorRendererClass();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ClientBehaviorRendererTypeTypeImpl <em>Client Behavior Renderer Type Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ClientBehaviorRendererTypeTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getClientBehaviorRendererTypeType()
-		 * @generated
-		 */
-		EClass CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE = eINSTANCE.getClientBehaviorRendererTypeType();
-
-								/**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE__TEXT_CONTENT = eINSTANCE.getClientBehaviorRendererTypeType_TextContent();
-
-								/**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE__ID = eINSTANCE.getClientBehaviorRendererTypeType_Id();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentClassTypeImpl <em>Component Class Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentClassTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getComponentClassType()
-		 * @generated
-		 */
-        EClass COMPONENT_CLASS_TYPE = eINSTANCE.getComponentClassType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute COMPONENT_CLASS_TYPE__TEXT_CONTENT = eINSTANCE.getComponentClassType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute COMPONENT_CLASS_TYPE__ID = eINSTANCE.getComponentClassType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentExtensionTypeImpl <em>Component Extension Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentExtensionTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getComponentExtensionType()
-		 * @generated
-		 */
-        EClass COMPONENT_EXTENSION_TYPE = eINSTANCE.getComponentExtensionType();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentFamilyTypeImpl <em>Component Family Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentFamilyTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getComponentFamilyType()
-		 * @generated
-		 */
-        EClass COMPONENT_FAMILY_TYPE = eINSTANCE.getComponentFamilyType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute COMPONENT_FAMILY_TYPE__TEXT_CONTENT = eINSTANCE.getComponentFamilyType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute COMPONENT_FAMILY_TYPE__ID = eINSTANCE.getComponentFamilyType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeImpl <em>Component Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getComponentType()
-		 * @generated
-		 */
-        EClass COMPONENT_TYPE = eINSTANCE.getComponentType();
-
-        /**
-		 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference COMPONENT_TYPE__DESCRIPTION = eINSTANCE.getComponentType_Description();
-
-        /**
-		 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference COMPONENT_TYPE__DISPLAY_NAME = eINSTANCE.getComponentType_DisplayName();
-
-        /**
-		 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference COMPONENT_TYPE__ICON = eINSTANCE.getComponentType_Icon();
-
-        /**
-		 * The meta object literal for the '<em><b>Component Type</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference COMPONENT_TYPE__COMPONENT_TYPE = eINSTANCE.getComponentType_ComponentType();
-
-        /**
-		 * The meta object literal for the '<em><b>Component Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference COMPONENT_TYPE__COMPONENT_CLASS = eINSTANCE.getComponentType_ComponentClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Facet</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference COMPONENT_TYPE__FACET = eINSTANCE.getComponentType_Facet();
-
-        /**
-		 * The meta object literal for the '<em><b>Attribute</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference COMPONENT_TYPE__ATTRIBUTE = eINSTANCE.getComponentType_Attribute();
-
-        /**
-		 * The meta object literal for the '<em><b>Property</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference COMPONENT_TYPE__PROPERTY = eINSTANCE.getComponentType_Property();
-
-        /**
-		 * The meta object literal for the '<em><b>Component Extension</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference COMPONENT_TYPE__COMPONENT_EXTENSION = eINSTANCE.getComponentType_ComponentExtension();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute COMPONENT_TYPE__ID = eINSTANCE.getComponentType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeTypeImpl <em>Component Type Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getComponentTypeType()
-		 * @generated
-		 */
-        EClass COMPONENT_TYPE_TYPE = eINSTANCE.getComponentTypeType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute COMPONENT_TYPE_TYPE__TEXT_CONTENT = eINSTANCE.getComponentTypeType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute COMPONENT_TYPE_TYPE__ID = eINSTANCE.getComponentTypeType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterClassTypeImpl <em>Converter Class Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterClassTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getConverterClassType()
-		 * @generated
-		 */
-        EClass CONVERTER_CLASS_TYPE = eINSTANCE.getConverterClassType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute CONVERTER_CLASS_TYPE__TEXT_CONTENT = eINSTANCE.getConverterClassType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute CONVERTER_CLASS_TYPE__ID = eINSTANCE.getConverterClassType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterForClassTypeImpl <em>Converter For Class Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterForClassTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getConverterForClassType()
-		 * @generated
-		 */
-        EClass CONVERTER_FOR_CLASS_TYPE = eINSTANCE.getConverterForClassType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute CONVERTER_FOR_CLASS_TYPE__TEXT_CONTENT = eINSTANCE.getConverterForClassType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute CONVERTER_FOR_CLASS_TYPE__ID = eINSTANCE.getConverterForClassType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterIdTypeImpl <em>Converter Id Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterIdTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getConverterIdType()
-		 * @generated
-		 */
-        EClass CONVERTER_ID_TYPE = eINSTANCE.getConverterIdType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute CONVERTER_ID_TYPE__TEXT_CONTENT = eINSTANCE.getConverterIdType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute CONVERTER_ID_TYPE__ID = eINSTANCE.getConverterIdType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterTypeImpl <em>Converter Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getConverterType()
-		 * @generated
-		 */
-        EClass CONVERTER_TYPE = eINSTANCE.getConverterType();
-
-        /**
-		 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference CONVERTER_TYPE__DESCRIPTION = eINSTANCE.getConverterType_Description();
-
-        /**
-		 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference CONVERTER_TYPE__DISPLAY_NAME = eINSTANCE.getConverterType_DisplayName();
-
-        /**
-		 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference CONVERTER_TYPE__ICON = eINSTANCE.getConverterType_Icon();
-
-        /**
-		 * The meta object literal for the '<em><b>Converter Id</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference CONVERTER_TYPE__CONVERTER_ID = eINSTANCE.getConverterType_ConverterId();
-
-        /**
-		 * The meta object literal for the '<em><b>Converter For Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference CONVERTER_TYPE__CONVERTER_FOR_CLASS = eINSTANCE.getConverterType_ConverterForClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Converter Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference CONVERTER_TYPE__CONVERTER_CLASS = eINSTANCE.getConverterType_ConverterClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Attribute</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference CONVERTER_TYPE__ATTRIBUTE = eINSTANCE.getConverterType_Attribute();
-
-        /**
-		 * The meta object literal for the '<em><b>Property</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference CONVERTER_TYPE__PROPERTY = eINSTANCE.getConverterType_Property();
-
-        /**
-		 * The meta object literal for the '<em><b>Converter Extension</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference CONVERTER_TYPE__CONVERTER_EXTENSION = eINSTANCE.getConverterType_ConverterExtension();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute CONVERTER_TYPE__ID = eINSTANCE.getConverterType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultLocaleTypeImpl <em>Default Locale Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultLocaleTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDefaultLocaleType()
-		 * @generated
-		 */
-        EClass DEFAULT_LOCALE_TYPE = eINSTANCE.getDefaultLocaleType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute DEFAULT_LOCALE_TYPE__TEXT_CONTENT = eINSTANCE.getDefaultLocaleType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute DEFAULT_LOCALE_TYPE__ID = eINSTANCE.getDefaultLocaleType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultRenderKitIdTypeImpl <em>Default Render Kit Id Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultRenderKitIdTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDefaultRenderKitIdType()
-		 * @generated
-		 */
-        EClass DEFAULT_RENDER_KIT_ID_TYPE = eINSTANCE.getDefaultRenderKitIdType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute DEFAULT_RENDER_KIT_ID_TYPE__TEXT_CONTENT = eINSTANCE.getDefaultRenderKitIdType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute DEFAULT_RENDER_KIT_ID_TYPE__ID = eINSTANCE.getDefaultRenderKitIdType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultValidatorsTypeImpl <em>Default Validators Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultValidatorsTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDefaultValidatorsType()
-		 * @generated
-		 */
-		EClass DEFAULT_VALIDATORS_TYPE = eINSTANCE.getDefaultValidatorsType();
-
-								/**
-		 * The meta object literal for the '<em><b>Validator Id</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DEFAULT_VALIDATORS_TYPE__VALIDATOR_ID = eINSTANCE.getDefaultValidatorsType_ValidatorId();
-
-								/**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute DEFAULT_VALIDATORS_TYPE__ID = eINSTANCE.getDefaultValidatorsType_Id();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultValueTypeImpl <em>Default Value Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultValueTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDefaultValueType()
-		 * @generated
-		 */
-        EClass DEFAULT_VALUE_TYPE = eINSTANCE.getDefaultValueType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute DEFAULT_VALUE_TYPE__TEXT_CONTENT = eINSTANCE.getDefaultValueType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute DEFAULT_VALUE_TYPE__ID = eINSTANCE.getDefaultValueType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DescriptionTypeImpl <em>Description Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DescriptionTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDescriptionType()
-		 * @generated
-		 */
-        EClass DESCRIPTION_TYPE = eINSTANCE.getDescriptionType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute DESCRIPTION_TYPE__TEXT_CONTENT = eINSTANCE.getDescriptionType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Lang</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute DESCRIPTION_TYPE__LANG = eINSTANCE.getDescriptionType_Lang();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute DESCRIPTION_TYPE__ID = eINSTANCE.getDescriptionType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DisplayNameTypeImpl <em>Display Name Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DisplayNameTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDisplayNameType()
-		 * @generated
-		 */
-        EClass DISPLAY_NAME_TYPE = eINSTANCE.getDisplayNameType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute DISPLAY_NAME_TYPE__TEXT_CONTENT = eINSTANCE.getDisplayNameType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Lang</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute DISPLAY_NAME_TYPE__LANG = eINSTANCE.getDisplayNameType_Lang();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute DISPLAY_NAME_TYPE__ID = eINSTANCE.getDisplayNameType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl <em>Document Root</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDocumentRoot()
-		 * @generated
-		 */
-        EClass DOCUMENT_ROOT = eINSTANCE.getDocumentRoot();
-
-        /**
-		 * The meta object literal for the '<em><b>Mixed</b></em>' attribute list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute DOCUMENT_ROOT__MIXED = eINSTANCE.getDocumentRoot_Mixed();
-
-        /**
-		 * The meta object literal for the '<em><b>XMLNS Prefix Map</b></em>' map feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__XMLNS_PREFIX_MAP = eINSTANCE.getDocumentRoot_XMLNSPrefixMap();
-
-        /**
-		 * The meta object literal for the '<em><b>XSI Schema Location</b></em>' map feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__XSI_SCHEMA_LOCATION = eINSTANCE.getDocumentRoot_XSISchemaLocation();
-
-        /**
-		 * The meta object literal for the '<em><b>Absolute Ordering</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__ABSOLUTE_ORDERING = eINSTANCE.getDocumentRoot_AbsoluteOrdering();
-
-								/**
-		 * The meta object literal for the '<em><b>Action Listener</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__ACTION_LISTENER = eINSTANCE.getDocumentRoot_ActionListener();
-
-        /**
-		 * The meta object literal for the '<em><b>Application</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__APPLICATION = eINSTANCE.getDocumentRoot_Application();
-
-        /**
-		 * The meta object literal for the '<em><b>Application Factory</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__APPLICATION_FACTORY = eINSTANCE.getDocumentRoot_ApplicationFactory();
-
-        /**
-		 * The meta object literal for the '<em><b>Attribute</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__ATTRIBUTE = eINSTANCE.getDocumentRoot_Attribute();
-
-        /**
-		 * The meta object literal for the '<em><b>Attribute Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__ATTRIBUTE_CLASS = eINSTANCE.getDocumentRoot_AttributeClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Attribute Extension</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__ATTRIBUTE_EXTENSION = eINSTANCE.getDocumentRoot_AttributeExtension();
-
-        /**
-		 * The meta object literal for the '<em><b>Attribute Name</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__ATTRIBUTE_NAME = eINSTANCE.getDocumentRoot_AttributeName();
-
-        /**
-		 * The meta object literal for the '<em><b>Behavior</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__BEHAVIOR = eINSTANCE.getDocumentRoot_Behavior();
-
-								/**
-		 * The meta object literal for the '<em><b>Behavior Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__BEHAVIOR_CLASS = eINSTANCE.getDocumentRoot_BehaviorClass();
-
-								/**
-		 * The meta object literal for the '<em><b>Behavior Id</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__BEHAVIOR_ID = eINSTANCE.getDocumentRoot_BehaviorId();
-
-								/**
-		 * The meta object literal for the '<em><b>Behavior Extension</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__BEHAVIOR_EXTENSION = eINSTANCE.getDocumentRoot_BehaviorExtension();
-
-								/**
-		 * The meta object literal for the '<em><b>Component</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__COMPONENT = eINSTANCE.getDocumentRoot_Component();
-
-        /**
-		 * The meta object literal for the '<em><b>Component Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__COMPONENT_CLASS = eINSTANCE.getDocumentRoot_ComponentClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Component Extension</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__COMPONENT_EXTENSION = eINSTANCE.getDocumentRoot_ComponentExtension();
-
-        /**
-		 * The meta object literal for the '<em><b>Component Family</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__COMPONENT_FAMILY = eINSTANCE.getDocumentRoot_ComponentFamily();
-
-        /**
-		 * The meta object literal for the '<em><b>Component Type</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__COMPONENT_TYPE = eINSTANCE.getDocumentRoot_ComponentType();
-
-        /**
-		 * The meta object literal for the '<em><b>Converter</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__CONVERTER = eINSTANCE.getDocumentRoot_Converter();
-
-        /**
-		 * The meta object literal for the '<em><b>Converter Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__CONVERTER_CLASS = eINSTANCE.getDocumentRoot_ConverterClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Converter For Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__CONVERTER_FOR_CLASS = eINSTANCE.getDocumentRoot_ConverterForClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Converter Id</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__CONVERTER_ID = eINSTANCE.getDocumentRoot_ConverterId();
-
-        /**
-		 * The meta object literal for the '<em><b>Default Locale</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__DEFAULT_LOCALE = eINSTANCE.getDocumentRoot_DefaultLocale();
-
-        /**
-		 * The meta object literal for the '<em><b>Default Render Kit Id</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__DEFAULT_RENDER_KIT_ID = eINSTANCE.getDocumentRoot_DefaultRenderKitId();
-
-        /**
-		 * The meta object literal for the '<em><b>Default Validators</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__DEFAULT_VALIDATORS = eINSTANCE.getDocumentRoot_DefaultValidators();
-
-								/**
-		 * The meta object literal for the '<em><b>Default Value</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__DEFAULT_VALUE = eINSTANCE.getDocumentRoot_DefaultValue();
-
-        /**
-		 * The meta object literal for the '<em><b>Description</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__DESCRIPTION = eINSTANCE.getDocumentRoot_Description();
-
-        /**
-		 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__DISPLAY_NAME = eINSTANCE.getDocumentRoot_DisplayName();
-
-        /**
-		 * The meta object literal for the '<em><b>Exception Handler Factory</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__EXCEPTION_HANDLER_FACTORY = eINSTANCE.getDocumentRoot_ExceptionHandlerFactory();
-
-								/**
-		 * The meta object literal for the '<em><b>External Context Factory</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__EXTERNAL_CONTEXT_FACTORY = eINSTANCE.getDocumentRoot_ExternalContextFactory();
-
-								/**
-		 * The meta object literal for the '<em><b>Faces Config</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__FACES_CONFIG = eINSTANCE.getDocumentRoot_FacesConfig();
-
-        /**
-		 * The meta object literal for the '<em><b>Faces Context Factory</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__FACES_CONTEXT_FACTORY = eINSTANCE.getDocumentRoot_FacesContextFactory();
-
-        /**
-		 * The meta object literal for the '<em><b>Facet</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__FACET = eINSTANCE.getDocumentRoot_Facet();
-
-        /**
-		 * The meta object literal for the '<em><b>Facet Extension</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__FACET_EXTENSION = eINSTANCE.getDocumentRoot_FacetExtension();
-
-        /**
-		 * The meta object literal for the '<em><b>Facet Name</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__FACET_NAME = eINSTANCE.getDocumentRoot_FacetName();
-
-        /**
-		 * The meta object literal for the '<em><b>Factory</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__FACTORY = eINSTANCE.getDocumentRoot_Factory();
-
-        /**
-		 * The meta object literal for the '<em><b>From Action</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__FROM_ACTION = eINSTANCE.getDocumentRoot_FromAction();
-
-        /**
-		 * The meta object literal for the '<em><b>From Outcome</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__FROM_OUTCOME = eINSTANCE.getDocumentRoot_FromOutcome();
-
-        /**
-		 * The meta object literal for the '<em><b>From View Id</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__FROM_VIEW_ID = eINSTANCE.getDocumentRoot_FromViewId();
-
-        /**
-		 * The meta object literal for the '<em><b>Icon</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__ICON = eINSTANCE.getDocumentRoot_Icon();
-
-        /**
-		 * The meta object literal for the '<em><b>If</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__IF = eINSTANCE.getDocumentRoot_If();
-
-								/**
-		 * The meta object literal for the '<em><b>Key</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__KEY = eINSTANCE.getDocumentRoot_Key();
-
-        /**
-		 * The meta object literal for the '<em><b>Key Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__KEY_CLASS = eINSTANCE.getDocumentRoot_KeyClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Large Icon</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__LARGE_ICON = eINSTANCE.getDocumentRoot_LargeIcon();
-
-        /**
-		 * The meta object literal for the '<em><b>Lifecycle</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__LIFECYCLE = eINSTANCE.getDocumentRoot_Lifecycle();
-
-        /**
-		 * The meta object literal for the '<em><b>Lifecycle Factory</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__LIFECYCLE_FACTORY = eINSTANCE.getDocumentRoot_LifecycleFactory();
-
-        /**
-		 * The meta object literal for the '<em><b>List Entries</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__LIST_ENTRIES = eINSTANCE.getDocumentRoot_ListEntries();
-
-        /**
-		 * The meta object literal for the '<em><b>Locale Config</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__LOCALE_CONFIG = eINSTANCE.getDocumentRoot_LocaleConfig();
-
-        /**
-		 * The meta object literal for the '<em><b>Managed Bean</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__MANAGED_BEAN = eINSTANCE.getDocumentRoot_ManagedBean();
-
-        /**
-		 * The meta object literal for the '<em><b>Managed Bean Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__MANAGED_BEAN_CLASS = eINSTANCE.getDocumentRoot_ManagedBeanClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Managed Bean Name</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__MANAGED_BEAN_NAME = eINSTANCE.getDocumentRoot_ManagedBeanName();
-
-        /**
-		 * The meta object literal for the '<em><b>Managed Bean Scope</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__MANAGED_BEAN_SCOPE = eINSTANCE.getDocumentRoot_ManagedBeanScope();
-
-        /**
-		 * The meta object literal for the '<em><b>Managed Property</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__MANAGED_PROPERTY = eINSTANCE.getDocumentRoot_ManagedProperty();
-
-        /**
-		 * The meta object literal for the '<em><b>Map Entries</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__MAP_ENTRIES = eINSTANCE.getDocumentRoot_MapEntries();
-
-        /**
-		 * The meta object literal for the '<em><b>Map Entry</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__MAP_ENTRY = eINSTANCE.getDocumentRoot_MapEntry();
-
-        /**
-		 * The meta object literal for the '<em><b>Message Bundle</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__MESSAGE_BUNDLE = eINSTANCE.getDocumentRoot_MessageBundle();
-
-        /**
-		 * The meta object literal for the '<em><b>Name</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__NAME = eINSTANCE.getDocumentRoot_Name();
-
-								/**
-		 * The meta object literal for the '<em><b>Navigation Case</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__NAVIGATION_CASE = eINSTANCE.getDocumentRoot_NavigationCase();
-
-        /**
-		 * The meta object literal for the '<em><b>Navigation Handler</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__NAVIGATION_HANDLER = eINSTANCE.getDocumentRoot_NavigationHandler();
-
-        /**
-		 * The meta object literal for the '<em><b>Navigation Rule</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__NAVIGATION_RULE = eINSTANCE.getDocumentRoot_NavigationRule();
-
-        /**
-		 * The meta object literal for the '<em><b>Null Value</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__NULL_VALUE = eINSTANCE.getDocumentRoot_NullValue();
-
-        /**
-		 * The meta object literal for the '<em><b>Ordering</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__ORDERING = eINSTANCE.getDocumentRoot_Ordering();
-
-								/**
-		 * The meta object literal for the '<em><b>Ordering Ordering</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__ORDERING_ORDERING = eINSTANCE.getDocumentRoot_OrderingOrdering();
-
-								/**
-		 * The meta object literal for the '<em><b>Others</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__OTHERS = eINSTANCE.getDocumentRoot_Others();
-
-								/**
-		 * The meta object literal for the '<em><b>Partial View Context Factory</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__PARTIAL_VIEW_CONTEXT_FACTORY = eINSTANCE.getDocumentRoot_PartialViewContextFactory();
-
-								/**
-		 * The meta object literal for the '<em><b>Phase Listener</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__PHASE_LISTENER = eINSTANCE.getDocumentRoot_PhaseListener();
-
-        /**
-		 * The meta object literal for the '<em><b>Property</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__PROPERTY = eINSTANCE.getDocumentRoot_Property();
-
-        /**
-		 * The meta object literal for the '<em><b>Property Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__PROPERTY_CLASS = eINSTANCE.getDocumentRoot_PropertyClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Property Extension</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__PROPERTY_EXTENSION = eINSTANCE.getDocumentRoot_PropertyExtension();
-
-        /**
-		 * The meta object literal for the '<em><b>Property Name</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__PROPERTY_NAME = eINSTANCE.getDocumentRoot_PropertyName();
-
-        /**
-		 * The meta object literal for the '<em><b>Property Resolver</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__PROPERTY_RESOLVER = eINSTANCE.getDocumentRoot_PropertyResolver();
-
-        /**
-		 * The meta object literal for the '<em><b>Redirect</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__REDIRECT = eINSTANCE.getDocumentRoot_Redirect();
-
-        /**
-		 * The meta object literal for the '<em><b>Redirect View Param</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__REDIRECT_VIEW_PARAM = eINSTANCE.getDocumentRoot_RedirectViewParam();
-
-								/**
-		 * The meta object literal for the '<em><b>Referenced Bean</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__REFERENCED_BEAN = eINSTANCE.getDocumentRoot_ReferencedBean();
-
-        /**
-		 * The meta object literal for the '<em><b>Referenced Bean Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__REFERENCED_BEAN_CLASS = eINSTANCE.getDocumentRoot_ReferencedBeanClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Referenced Bean Name</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__REFERENCED_BEAN_NAME = eINSTANCE.getDocumentRoot_ReferencedBeanName();
-
-        /**
-		 * The meta object literal for the '<em><b>Renderer</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__RENDERER = eINSTANCE.getDocumentRoot_Renderer();
-
-        /**
-		 * The meta object literal for the '<em><b>Renderer Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__RENDERER_CLASS = eINSTANCE.getDocumentRoot_RendererClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Renderer Extension</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__RENDERER_EXTENSION = eINSTANCE.getDocumentRoot_RendererExtension();
-
-        /**
-		 * The meta object literal for the '<em><b>Renderer Type</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__RENDERER_TYPE = eINSTANCE.getDocumentRoot_RendererType();
-
-        /**
-		 * The meta object literal for the '<em><b>Render Kit</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__RENDER_KIT = eINSTANCE.getDocumentRoot_RenderKit();
-
-        /**
-		 * The meta object literal for the '<em><b>Render Kit Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__RENDER_KIT_CLASS = eINSTANCE.getDocumentRoot_RenderKitClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Render Kit Factory</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__RENDER_KIT_FACTORY = eINSTANCE.getDocumentRoot_RenderKitFactory();
-
-        /**
-		 * The meta object literal for the '<em><b>Render Kit Id</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__RENDER_KIT_ID = eINSTANCE.getDocumentRoot_RenderKitId();
-
-        /**
-		 * The meta object literal for the '<em><b>Resource Handler</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__RESOURCE_HANDLER = eINSTANCE.getDocumentRoot_ResourceHandler();
-
-								/**
-		 * The meta object literal for the '<em><b>Small Icon</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__SMALL_ICON = eINSTANCE.getDocumentRoot_SmallIcon();
-
-        /**
-		 * The meta object literal for the '<em><b>Source Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__SOURCE_CLASS = eINSTANCE.getDocumentRoot_SourceClass();
-
-								/**
-		 * The meta object literal for the '<em><b>State Manager</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__STATE_MANAGER = eINSTANCE.getDocumentRoot_StateManager();
-
-        /**
-		 * The meta object literal for the '<em><b>Suggested Value</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__SUGGESTED_VALUE = eINSTANCE.getDocumentRoot_SuggestedValue();
-
-        /**
-		 * The meta object literal for the '<em><b>Supported Locale</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__SUPPORTED_LOCALE = eINSTANCE.getDocumentRoot_SupportedLocale();
-
-        /**
-		 * The meta object literal for the '<em><b>System Event Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__SYSTEM_EVENT_CLASS = eINSTANCE.getDocumentRoot_SystemEventClass();
-
-								/**
-		 * The meta object literal for the '<em><b>System Event Listener</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER = eINSTANCE.getDocumentRoot_SystemEventListener();
-
-								/**
-		 * The meta object literal for the '<em><b>System Event Listener Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER_CLASS = eINSTANCE.getDocumentRoot_SystemEventListenerClass();
-
-								/**
-		 * The meta object literal for the '<em><b>Tag Handler Delegate Factory</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__TAG_HANDLER_DELEGATE_FACTORY = eINSTANCE.getDocumentRoot_TagHandlerDelegateFactory();
-
-								/**
-		 * The meta object literal for the '<em><b>To View Id</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__TO_VIEW_ID = eINSTANCE.getDocumentRoot_ToViewId();
-
-        /**
-		 * The meta object literal for the '<em><b>Validator</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__VALIDATOR = eINSTANCE.getDocumentRoot_Validator();
-
-        /**
-		 * The meta object literal for the '<em><b>Validator Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__VALIDATOR_CLASS = eINSTANCE.getDocumentRoot_ValidatorClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Validator Id</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__VALIDATOR_ID = eINSTANCE.getDocumentRoot_ValidatorId();
-
-        /**
-		 * The meta object literal for the '<em><b>Value</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__VALUE = eINSTANCE.getDocumentRoot_Value();
-
-        /**
-		 * The meta object literal for the '<em><b>Value Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__VALUE_CLASS = eINSTANCE.getDocumentRoot_ValueClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Variable Resolver</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__VARIABLE_RESOLVER = eINSTANCE.getDocumentRoot_VariableResolver();
-
-        /**
-		 * The meta object literal for the '<em><b>View Declaration Language Factory</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__VIEW_DECLARATION_LANGUAGE_FACTORY = eINSTANCE.getDocumentRoot_ViewDeclarationLanguageFactory();
-
-								/**
-		 * The meta object literal for the '<em><b>View Handler</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DOCUMENT_ROOT__VIEW_HANDLER = eINSTANCE.getDocumentRoot_ViewHandler();
-
-        /**
-		 * The meta object literal for the '<em><b>Visit Context Factory</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference DOCUMENT_ROOT__VISIT_CONTEXT_FACTORY = eINSTANCE.getDocumentRoot_VisitContextFactory();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DynamicAttributeImpl <em>Dynamic Attribute</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DynamicAttributeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDynamicAttribute()
-		 * @generated
-		 */
-        EClass DYNAMIC_ATTRIBUTE = eINSTANCE.getDynamicAttribute();
-
-        /**
-		 * The meta object literal for the '<em><b>Name</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute DYNAMIC_ATTRIBUTE__NAME = eINSTANCE.getDynamicAttribute_Name();
-
-        /**
-		 * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute DYNAMIC_ATTRIBUTE__VALUE = eINSTANCE.getDynamicAttribute_Value();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DynamicElementImpl <em>Dynamic Element</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.DynamicElementImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getDynamicElement()
-		 * @generated
-		 */
-        EClass DYNAMIC_ELEMENT = eINSTANCE.getDynamicElement();
-
-        /**
-		 * The meta object literal for the '<em><b>Child Nodes</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DYNAMIC_ELEMENT__CHILD_NODES = eINSTANCE.getDynamicElement_ChildNodes();
-
-        /**
-		 * The meta object literal for the '<em><b>Attributes</b></em>' reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference DYNAMIC_ELEMENT__ATTRIBUTES = eINSTANCE.getDynamicElement_Attributes();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute DYNAMIC_ELEMENT__TEXT_CONTENT = eINSTANCE.getDynamicElement_TextContent();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ELResolverTypeImpl <em>EL Resolver Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ELResolverTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getELResolverType()
-		 * @generated
-		 */
-        EClass EL_RESOLVER_TYPE = eINSTANCE.getELResolverType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute EL_RESOLVER_TYPE__TEXT_CONTENT = eINSTANCE.getELResolverType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute EL_RESOLVER_TYPE__ID = eINSTANCE.getELResolverType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ExceptionHandlerFactoryTypeImpl <em>Exception Handler Factory Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ExceptionHandlerFactoryTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getExceptionHandlerFactoryType()
-		 * @generated
-		 */
-		EClass EXCEPTION_HANDLER_FACTORY_TYPE = eINSTANCE.getExceptionHandlerFactoryType();
-
-								/**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute EXCEPTION_HANDLER_FACTORY_TYPE__TEXT_CONTENT = eINSTANCE.getExceptionHandlerFactoryType_TextContent();
-
-								/**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute EXCEPTION_HANDLER_FACTORY_TYPE__ID = eINSTANCE.getExceptionHandlerFactoryType_Id();
-
-								/**
-		 * The meta object literal for the '<em><b>Name</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute DYNAMIC_ELEMENT__NAME = eINSTANCE.getDynamicElement_Name();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl <em>Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFacesConfigType()
-		 * @generated
-		 */
-        EClass FACES_CONFIG_TYPE = eINSTANCE.getFacesConfigType();
-
-        /**
-		 * The meta object literal for the '<em><b>Application</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference FACES_CONFIG_TYPE__APPLICATION = eINSTANCE.getFacesConfigType_Application();
-
-        /**
-		 * The meta object literal for the '<em><b>Ordering</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference FACES_CONFIG_TYPE__ORDERING = eINSTANCE.getFacesConfigType_Ordering();
-
-								/**
-		 * The meta object literal for the '<em><b>Absolute Ordering</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference FACES_CONFIG_TYPE__ABSOLUTE_ORDERING = eINSTANCE.getFacesConfigType_AbsoluteOrdering();
-
-								/**
-		 * The meta object literal for the '<em><b>Factory</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference FACES_CONFIG_TYPE__FACTORY = eINSTANCE.getFacesConfigType_Factory();
-
-        /**
-		 * The meta object literal for the '<em><b>Component</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference FACES_CONFIG_TYPE__COMPONENT = eINSTANCE.getFacesConfigType_Component();
-
-        /**
-		 * The meta object literal for the '<em><b>Converter</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference FACES_CONFIG_TYPE__CONVERTER = eINSTANCE.getFacesConfigType_Converter();
-
-        /**
-		 * The meta object literal for the '<em><b>Managed Bean</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference FACES_CONFIG_TYPE__MANAGED_BEAN = eINSTANCE.getFacesConfigType_ManagedBean();
-
-        /**
-		 * The meta object literal for the '<em><b>Name</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference FACES_CONFIG_TYPE__NAME = eINSTANCE.getFacesConfigType_Name();
-
-								/**
-		 * The meta object literal for the '<em><b>Navigation Rule</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference FACES_CONFIG_TYPE__NAVIGATION_RULE = eINSTANCE.getFacesConfigType_NavigationRule();
-
-        /**
-		 * The meta object literal for the '<em><b>Referenced Bean</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference FACES_CONFIG_TYPE__REFERENCED_BEAN = eINSTANCE.getFacesConfigType_ReferencedBean();
-
-        /**
-		 * The meta object literal for the '<em><b>Render Kit</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference FACES_CONFIG_TYPE__RENDER_KIT = eINSTANCE.getFacesConfigType_RenderKit();
-
-        /**
-		 * The meta object literal for the '<em><b>Lifecycle</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference FACES_CONFIG_TYPE__LIFECYCLE = eINSTANCE.getFacesConfigType_Lifecycle();
-
-        /**
-		 * The meta object literal for the '<em><b>Validator</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference FACES_CONFIG_TYPE__VALIDATOR = eINSTANCE.getFacesConfigType_Validator();
-
-        /**
-		 * The meta object literal for the '<em><b>Behavior</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference FACES_CONFIG_TYPE__BEHAVIOR = eINSTANCE.getFacesConfigType_Behavior();
-
-								/**
-		 * The meta object literal for the '<em><b>Faces Config Extension</b></em>' reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference FACES_CONFIG_TYPE__FACES_CONFIG_EXTENSION = eINSTANCE.getFacesConfigType_FacesConfigExtension();
-
-        /**
-		 * The meta object literal for the '<em><b>Xmlns</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute FACES_CONFIG_TYPE__XMLNS = eINSTANCE.getFacesConfigType_Xmlns();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute FACES_CONFIG_TYPE__ID = eINSTANCE.getFacesConfigType_Id();
-
-        /**
-		 * The meta object literal for the '<em><b>Metadata Complete</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute FACES_CONFIG_TYPE__METADATA_COMPLETE = eINSTANCE.getFacesConfigType_MetadataComplete();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesContextFactoryTypeImpl <em>Faces Context Factory Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesContextFactoryTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFacesContextFactoryType()
-		 * @generated
-		 */
-        EClass FACES_CONTEXT_FACTORY_TYPE = eINSTANCE.getFacesContextFactoryType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute FACES_CONTEXT_FACTORY_TYPE__TEXT_CONTENT = eINSTANCE.getFacesContextFactoryType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute FACES_CONTEXT_FACTORY_TYPE__ID = eINSTANCE.getFacesContextFactoryType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacetExtensionTypeImpl <em>Facet Extension Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacetExtensionTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFacetExtensionType()
-		 * @generated
-		 */
-        EClass FACET_EXTENSION_TYPE = eINSTANCE.getFacetExtensionType();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacetNameTypeImpl <em>Facet Name Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacetNameTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFacetNameType()
-		 * @generated
-		 */
-        EClass FACET_NAME_TYPE = eINSTANCE.getFacetNameType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute FACET_NAME_TYPE__TEXT_CONTENT = eINSTANCE.getFacetNameType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute FACET_NAME_TYPE__ID = eINSTANCE.getFacetNameType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacetTypeImpl <em>Facet Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacetTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFacetType()
-		 * @generated
-		 */
-        EClass FACET_TYPE = eINSTANCE.getFacetType();
-
-        /**
-		 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference FACET_TYPE__DESCRIPTION = eINSTANCE.getFacetType_Description();
-
-        /**
-		 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference FACET_TYPE__DISPLAY_NAME = eINSTANCE.getFacetType_DisplayName();
-
-        /**
-		 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference FACET_TYPE__ICON = eINSTANCE.getFacetType_Icon();
-
-        /**
-		 * The meta object literal for the '<em><b>Facet Name</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference FACET_TYPE__FACET_NAME = eINSTANCE.getFacetType_FacetName();
-
-        /**
-		 * The meta object literal for the '<em><b>Facet Extension</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference FACET_TYPE__FACET_EXTENSION = eINSTANCE.getFacetType_FacetExtension();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute FACET_TYPE__ID = eINSTANCE.getFacetType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryTypeImpl <em>Factory Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFactoryType()
-		 * @generated
-		 */
-        EClass FACTORY_TYPE = eINSTANCE.getFactoryType();
-
-        /**
-		 * The meta object literal for the '<em><b>Application Factory</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference FACTORY_TYPE__APPLICATION_FACTORY = eINSTANCE.getFactoryType_ApplicationFactory();
-
-        /**
-		 * The meta object literal for the '<em><b>Exception Handler Factory</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference FACTORY_TYPE__EXCEPTION_HANDLER_FACTORY = eINSTANCE.getFactoryType_ExceptionHandlerFactory();
-
-								/**
-		 * The meta object literal for the '<em><b>External Context Factory</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference FACTORY_TYPE__EXTERNAL_CONTEXT_FACTORY = eINSTANCE.getFactoryType_ExternalContextFactory();
-
-								/**
-		 * The meta object literal for the '<em><b>Faces Context Factory</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference FACTORY_TYPE__FACES_CONTEXT_FACTORY = eINSTANCE.getFactoryType_FacesContextFactory();
-
-        /**
-		 * The meta object literal for the '<em><b>Partial View Context Factory</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference FACTORY_TYPE__PARTIAL_VIEW_CONTEXT_FACTORY = eINSTANCE.getFactoryType_PartialViewContextFactory();
-
-								/**
-		 * The meta object literal for the '<em><b>Lifecycle Factory</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference FACTORY_TYPE__LIFECYCLE_FACTORY = eINSTANCE.getFactoryType_LifecycleFactory();
-
-        /**
-		 * The meta object literal for the '<em><b>View Declaration Language Factory</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference FACTORY_TYPE__VIEW_DECLARATION_LANGUAGE_FACTORY = eINSTANCE.getFactoryType_ViewDeclarationLanguageFactory();
-
-								/**
-		 * The meta object literal for the '<em><b>Tag Handler Delegate Factory</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference FACTORY_TYPE__TAG_HANDLER_DELEGATE_FACTORY = eINSTANCE.getFactoryType_TagHandlerDelegateFactory();
-
-								/**
-		 * The meta object literal for the '<em><b>Render Kit Factory</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference FACTORY_TYPE__RENDER_KIT_FACTORY = eINSTANCE.getFactoryType_RenderKitFactory();
-
-        /**
-		 * The meta object literal for the '<em><b>Visit Context Factory</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference FACTORY_TYPE__VISIT_CONTEXT_FACTORY = eINSTANCE.getFactoryType_VisitContextFactory();
-
-								/**
-		 * The meta object literal for the '<em><b>Factory Extension</b></em>' reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference FACTORY_TYPE__FACTORY_EXTENSION = eINSTANCE.getFactoryType_FactoryExtension();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute FACTORY_TYPE__ID = eINSTANCE.getFactoryType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FromActionTypeImpl <em>From Action Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FromActionTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFromActionType()
-		 * @generated
-		 */
-        EClass FROM_ACTION_TYPE = eINSTANCE.getFromActionType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute FROM_ACTION_TYPE__TEXT_CONTENT = eINSTANCE.getFromActionType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute FROM_ACTION_TYPE__ID = eINSTANCE.getFromActionType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FromOutcomeTypeImpl <em>From Outcome Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FromOutcomeTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFromOutcomeType()
-		 * @generated
-		 */
-        EClass FROM_OUTCOME_TYPE = eINSTANCE.getFromOutcomeType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute FROM_OUTCOME_TYPE__TEXT_CONTENT = eINSTANCE.getFromOutcomeType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute FROM_OUTCOME_TYPE__ID = eINSTANCE.getFromOutcomeType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FromViewIdTypeImpl <em>From View Id Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FromViewIdTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFromViewIdType()
-		 * @generated
-		 */
-        EClass FROM_VIEW_ID_TYPE = eINSTANCE.getFromViewIdType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute FROM_VIEW_ID_TYPE__TEXT_CONTENT = eINSTANCE.getFromViewIdType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute FROM_VIEW_ID_TYPE__ID = eINSTANCE.getFromViewIdType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.IconTypeImpl <em>Icon Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.IconTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getIconType()
-		 * @generated
-		 */
-        EClass ICON_TYPE = eINSTANCE.getIconType();
-
-        /**
-		 * The meta object literal for the '<em><b>Small Icon</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference ICON_TYPE__SMALL_ICON = eINSTANCE.getIconType_SmallIcon();
-
-        /**
-		 * The meta object literal for the '<em><b>Large Icon</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference ICON_TYPE__LARGE_ICON = eINSTANCE.getIconType_LargeIcon();
-
-        /**
-		 * The meta object literal for the '<em><b>Lang</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute ICON_TYPE__LANG = eINSTANCE.getIconType_Lang();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute ICON_TYPE__ID = eINSTANCE.getIconType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.IfTypeImpl <em>If Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.IfTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getIfType()
-		 * @generated
-		 */
-		EClass IF_TYPE = eINSTANCE.getIfType();
-
-								/**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute IF_TYPE__TEXT_CONTENT = eINSTANCE.getIfType_TextContent();
-
-								/**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute IF_TYPE__ID = eINSTANCE.getIfType_Id();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.KeyClassTypeImpl <em>Key Class Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.KeyClassTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getKeyClassType()
-		 * @generated
-		 */
-        EClass KEY_CLASS_TYPE = eINSTANCE.getKeyClassType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute KEY_CLASS_TYPE__TEXT_CONTENT = eINSTANCE.getKeyClassType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute KEY_CLASS_TYPE__ID = eINSTANCE.getKeyClassType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.KeyTypeImpl <em>Key Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.KeyTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getKeyType()
-		 * @generated
-		 */
-        EClass KEY_TYPE = eINSTANCE.getKeyType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute KEY_TYPE__TEXT_CONTENT = eINSTANCE.getKeyType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute KEY_TYPE__ID = eINSTANCE.getKeyType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LargeIconTypeImpl <em>Large Icon Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.LargeIconTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getLargeIconType()
-		 * @generated
-		 */
-        EClass LARGE_ICON_TYPE = eINSTANCE.getLargeIconType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute LARGE_ICON_TYPE__TEXT_CONTENT = eINSTANCE.getLargeIconType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute LARGE_ICON_TYPE__ID = eINSTANCE.getLargeIconType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LifecycleFactoryTypeImpl <em>Lifecycle Factory Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.LifecycleFactoryTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getLifecycleFactoryType()
-		 * @generated
-		 */
-        EClass LIFECYCLE_FACTORY_TYPE = eINSTANCE.getLifecycleFactoryType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute LIFECYCLE_FACTORY_TYPE__TEXT_CONTENT = eINSTANCE.getLifecycleFactoryType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute LIFECYCLE_FACTORY_TYPE__ID = eINSTANCE.getLifecycleFactoryType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LifecycleTypeImpl <em>Lifecycle Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.LifecycleTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getLifecycleType()
-		 * @generated
-		 */
-        EClass LIFECYCLE_TYPE = eINSTANCE.getLifecycleType();
-
-        /**
-		 * The meta object literal for the '<em><b>Phase Listener</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference LIFECYCLE_TYPE__PHASE_LISTENER = eINSTANCE.getLifecycleType_PhaseListener();
-
-        /**
-		 * The meta object literal for the '<em><b>Lifecycle Extension</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference LIFECYCLE_TYPE__LIFECYCLE_EXTENSION = eINSTANCE.getLifecycleType_LifecycleExtension();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute LIFECYCLE_TYPE__ID = eINSTANCE.getLifecycleType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ListEntriesTypeImpl <em>List Entries Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ListEntriesTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getListEntriesType()
-		 * @generated
-		 */
-        EClass LIST_ENTRIES_TYPE = eINSTANCE.getListEntriesType();
-
-        /**
-		 * The meta object literal for the '<em><b>Value Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference LIST_ENTRIES_TYPE__VALUE_CLASS = eINSTANCE.getListEntriesType_ValueClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Null Value</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference LIST_ENTRIES_TYPE__NULL_VALUE = eINSTANCE.getListEntriesType_NullValue();
-
-        /**
-		 * The meta object literal for the '<em><b>Value</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference LIST_ENTRIES_TYPE__VALUE = eINSTANCE.getListEntriesType_Value();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute LIST_ENTRIES_TYPE__ID = eINSTANCE.getListEntriesType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LocaleConfigTypeImpl <em>Locale Config Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.LocaleConfigTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getLocaleConfigType()
-		 * @generated
-		 */
-        EClass LOCALE_CONFIG_TYPE = eINSTANCE.getLocaleConfigType();
-
-        /**
-		 * The meta object literal for the '<em><b>Default Locale</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference LOCALE_CONFIG_TYPE__DEFAULT_LOCALE = eINSTANCE.getLocaleConfigType_DefaultLocale();
-
-        /**
-		 * The meta object literal for the '<em><b>Supported Locale</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference LOCALE_CONFIG_TYPE__SUPPORTED_LOCALE = eINSTANCE.getLocaleConfigType_SupportedLocale();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute LOCALE_CONFIG_TYPE__ID = eINSTANCE.getLocaleConfigType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanClassTypeImpl <em>Managed Bean Class Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanClassTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getManagedBeanClassType()
-		 * @generated
-		 */
-        EClass MANAGED_BEAN_CLASS_TYPE = eINSTANCE.getManagedBeanClassType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute MANAGED_BEAN_CLASS_TYPE__TEXT_CONTENT = eINSTANCE.getManagedBeanClassType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute MANAGED_BEAN_CLASS_TYPE__ID = eINSTANCE.getManagedBeanClassType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanNameTypeImpl <em>Managed Bean Name Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanNameTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getManagedBeanNameType()
-		 * @generated
-		 */
-        EClass MANAGED_BEAN_NAME_TYPE = eINSTANCE.getManagedBeanNameType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute MANAGED_BEAN_NAME_TYPE__TEXT_CONTENT = eINSTANCE.getManagedBeanNameType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute MANAGED_BEAN_NAME_TYPE__ID = eINSTANCE.getManagedBeanNameType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanScopeTypeImpl <em>Managed Bean Scope Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanScopeTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getManagedBeanScopeType()
-		 * @generated
-		 */
-        EClass MANAGED_BEAN_SCOPE_TYPE = eINSTANCE.getManagedBeanScopeType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute MANAGED_BEAN_SCOPE_TYPE__TEXT_CONTENT = eINSTANCE.getManagedBeanScopeType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute MANAGED_BEAN_SCOPE_TYPE__ID = eINSTANCE.getManagedBeanScopeType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanTypeImpl <em>Managed Bean Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getManagedBeanType()
-		 * @generated
-		 */
-        EClass MANAGED_BEAN_TYPE = eINSTANCE.getManagedBeanType();
-
-        /**
-		 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MANAGED_BEAN_TYPE__DESCRIPTION = eINSTANCE.getManagedBeanType_Description();
-
-        /**
-		 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MANAGED_BEAN_TYPE__DISPLAY_NAME = eINSTANCE.getManagedBeanType_DisplayName();
-
-        /**
-		 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MANAGED_BEAN_TYPE__ICON = eINSTANCE.getManagedBeanType_Icon();
-
-        /**
-		 * The meta object literal for the '<em><b>Managed Bean Name</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MANAGED_BEAN_TYPE__MANAGED_BEAN_NAME = eINSTANCE.getManagedBeanType_ManagedBeanName();
-
-        /**
-		 * The meta object literal for the '<em><b>Managed Bean Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MANAGED_BEAN_TYPE__MANAGED_BEAN_CLASS = eINSTANCE.getManagedBeanType_ManagedBeanClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Managed Bean Scope</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MANAGED_BEAN_TYPE__MANAGED_BEAN_SCOPE = eINSTANCE.getManagedBeanType_ManagedBeanScope();
-
-        /**
-		 * The meta object literal for the '<em><b>Managed Property</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MANAGED_BEAN_TYPE__MANAGED_PROPERTY = eINSTANCE.getManagedBeanType_ManagedProperty();
-
-        /**
-		 * The meta object literal for the '<em><b>Map Entries</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MANAGED_BEAN_TYPE__MAP_ENTRIES = eINSTANCE.getManagedBeanType_MapEntries();
-
-        /**
-		 * The meta object literal for the '<em><b>List Entries</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MANAGED_BEAN_TYPE__LIST_ENTRIES = eINSTANCE.getManagedBeanType_ListEntries();
-
-        /**
-		 * The meta object literal for the '<em><b>Managed Bean Extension</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MANAGED_BEAN_TYPE__MANAGED_BEAN_EXTENSION = eINSTANCE.getManagedBeanType_ManagedBeanExtension();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute MANAGED_BEAN_TYPE__ID = eINSTANCE.getManagedBeanType_Id();
-
-        /**
-		 * The meta object literal for the '<em><b>Eager</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute MANAGED_BEAN_TYPE__EAGER = eINSTANCE.getManagedBeanType_Eager();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedPropertyTypeImpl <em>Managed Property Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedPropertyTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getManagedPropertyType()
-		 * @generated
-		 */
-        EClass MANAGED_PROPERTY_TYPE = eINSTANCE.getManagedPropertyType();
-
-        /**
-		 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MANAGED_PROPERTY_TYPE__DESCRIPTION = eINSTANCE.getManagedPropertyType_Description();
-
-        /**
-		 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MANAGED_PROPERTY_TYPE__DISPLAY_NAME = eINSTANCE.getManagedPropertyType_DisplayName();
-
-        /**
-		 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MANAGED_PROPERTY_TYPE__ICON = eINSTANCE.getManagedPropertyType_Icon();
-
-        /**
-		 * The meta object literal for the '<em><b>Property Name</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MANAGED_PROPERTY_TYPE__PROPERTY_NAME = eINSTANCE.getManagedPropertyType_PropertyName();
-
-        /**
-		 * The meta object literal for the '<em><b>Property Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MANAGED_PROPERTY_TYPE__PROPERTY_CLASS = eINSTANCE.getManagedPropertyType_PropertyClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Map Entries</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MANAGED_PROPERTY_TYPE__MAP_ENTRIES = eINSTANCE.getManagedPropertyType_MapEntries();
-
-        /**
-		 * The meta object literal for the '<em><b>Null Value</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MANAGED_PROPERTY_TYPE__NULL_VALUE = eINSTANCE.getManagedPropertyType_NullValue();
-
-        /**
-		 * The meta object literal for the '<em><b>Value</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MANAGED_PROPERTY_TYPE__VALUE = eINSTANCE.getManagedPropertyType_Value();
-
-        /**
-		 * The meta object literal for the '<em><b>List Entries</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MANAGED_PROPERTY_TYPE__LIST_ENTRIES = eINSTANCE.getManagedPropertyType_ListEntries();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute MANAGED_PROPERTY_TYPE__ID = eINSTANCE.getManagedPropertyType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.MapEntriesTypeImpl <em>Map Entries Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.MapEntriesTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getMapEntriesType()
-		 * @generated
-		 */
-        EClass MAP_ENTRIES_TYPE = eINSTANCE.getMapEntriesType();
-
-        /**
-		 * The meta object literal for the '<em><b>Key Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MAP_ENTRIES_TYPE__KEY_CLASS = eINSTANCE.getMapEntriesType_KeyClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Value Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MAP_ENTRIES_TYPE__VALUE_CLASS = eINSTANCE.getMapEntriesType_ValueClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Map Entry</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MAP_ENTRIES_TYPE__MAP_ENTRY = eINSTANCE.getMapEntriesType_MapEntry();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute MAP_ENTRIES_TYPE__ID = eINSTANCE.getMapEntriesType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.MapEntryTypeImpl <em>Map Entry Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.MapEntryTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getMapEntryType()
-		 * @generated
-		 */
-        EClass MAP_ENTRY_TYPE = eINSTANCE.getMapEntryType();
-
-        /**
-		 * The meta object literal for the '<em><b>Key</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MAP_ENTRY_TYPE__KEY = eINSTANCE.getMapEntryType_Key();
-
-        /**
-		 * The meta object literal for the '<em><b>Null Value</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MAP_ENTRY_TYPE__NULL_VALUE = eINSTANCE.getMapEntryType_NullValue();
-
-        /**
-		 * The meta object literal for the '<em><b>Value</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference MAP_ENTRY_TYPE__VALUE = eINSTANCE.getMapEntryType_Value();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute MAP_ENTRY_TYPE__ID = eINSTANCE.getMapEntryType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.MessageBundleTypeImpl <em>Message Bundle Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.MessageBundleTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getMessageBundleType()
-		 * @generated
-		 */
-        EClass MESSAGE_BUNDLE_TYPE = eINSTANCE.getMessageBundleType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute MESSAGE_BUNDLE_TYPE__TEXT_CONTENT = eINSTANCE.getMessageBundleType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute MESSAGE_BUNDLE_TYPE__ID = eINSTANCE.getMessageBundleType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NameTypeImpl <em>Name Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.NameTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getNameType()
-		 * @generated
-		 */
-		EClass NAME_TYPE = eINSTANCE.getNameType();
-
-								/**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute NAME_TYPE__TEXT_CONTENT = eINSTANCE.getNameType_TextContent();
-
-								/**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute NAME_TYPE__ID = eINSTANCE.getNameType_Id();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationCaseTypeImpl <em>Navigation Case Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationCaseTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getNavigationCaseType()
-		 * @generated
-		 */
-        EClass NAVIGATION_CASE_TYPE = eINSTANCE.getNavigationCaseType();
-
-        /**
-		 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference NAVIGATION_CASE_TYPE__DESCRIPTION = eINSTANCE.getNavigationCaseType_Description();
-
-        /**
-		 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference NAVIGATION_CASE_TYPE__DISPLAY_NAME = eINSTANCE.getNavigationCaseType_DisplayName();
-
-        /**
-		 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference NAVIGATION_CASE_TYPE__ICON = eINSTANCE.getNavigationCaseType_Icon();
-
-        /**
-		 * The meta object literal for the '<em><b>From Action</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference NAVIGATION_CASE_TYPE__FROM_ACTION = eINSTANCE.getNavigationCaseType_FromAction();
-
-        /**
-		 * The meta object literal for the '<em><b>From Outcome</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference NAVIGATION_CASE_TYPE__FROM_OUTCOME = eINSTANCE.getNavigationCaseType_FromOutcome();
-
-        /**
-		 * The meta object literal for the '<em><b>If</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference NAVIGATION_CASE_TYPE__IF = eINSTANCE.getNavigationCaseType_If();
-
-								/**
-		 * The meta object literal for the '<em><b>To View Id</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference NAVIGATION_CASE_TYPE__TO_VIEW_ID = eINSTANCE.getNavigationCaseType_ToViewId();
-
-        /**
-		 * The meta object literal for the '<em><b>Redirect</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference NAVIGATION_CASE_TYPE__REDIRECT = eINSTANCE.getNavigationCaseType_Redirect();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute NAVIGATION_CASE_TYPE__ID = eINSTANCE.getNavigationCaseType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationHandlerTypeImpl <em>Navigation Handler Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationHandlerTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getNavigationHandlerType()
-		 * @generated
-		 */
-        EClass NAVIGATION_HANDLER_TYPE = eINSTANCE.getNavigationHandlerType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute NAVIGATION_HANDLER_TYPE__TEXT_CONTENT = eINSTANCE.getNavigationHandlerType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute NAVIGATION_HANDLER_TYPE__ID = eINSTANCE.getNavigationHandlerType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationRuleTypeImpl <em>Navigation Rule Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationRuleTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getNavigationRuleType()
-		 * @generated
-		 */
-        EClass NAVIGATION_RULE_TYPE = eINSTANCE.getNavigationRuleType();
-
-        /**
-		 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference NAVIGATION_RULE_TYPE__DESCRIPTION = eINSTANCE.getNavigationRuleType_Description();
-
-        /**
-		 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference NAVIGATION_RULE_TYPE__DISPLAY_NAME = eINSTANCE.getNavigationRuleType_DisplayName();
-
-        /**
-		 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference NAVIGATION_RULE_TYPE__ICON = eINSTANCE.getNavigationRuleType_Icon();
-
-        /**
-		 * The meta object literal for the '<em><b>From View Id</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference NAVIGATION_RULE_TYPE__FROM_VIEW_ID = eINSTANCE.getNavigationRuleType_FromViewId();
-
-        /**
-		 * The meta object literal for the '<em><b>Navigation Case</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference NAVIGATION_RULE_TYPE__NAVIGATION_CASE = eINSTANCE.getNavigationRuleType_NavigationCase();
-
-        /**
-		 * The meta object literal for the '<em><b>Navigation Rule Extension</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference NAVIGATION_RULE_TYPE__NAVIGATION_RULE_EXTENSION = eINSTANCE.getNavigationRuleType_NavigationRuleExtension();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute NAVIGATION_RULE_TYPE__ID = eINSTANCE.getNavigationRuleType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NullValueTypeImpl <em>Null Value Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.NullValueTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getNullValueType()
-		 * @generated
-		 */
-        EClass NULL_VALUE_TYPE = eINSTANCE.getNullValueType();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute NULL_VALUE_TYPE__ID = eINSTANCE.getNullValueType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.OrderingTypeImpl <em>Ordering Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.OrderingTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getOrderingType()
-		 * @generated
-		 */
-		EClass ORDERING_TYPE = eINSTANCE.getOrderingType();
-
-								/**
-		 * The meta object literal for the '<em><b>Before</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference ORDERING_TYPE__BEFORE = eINSTANCE.getOrderingType_Before();
-
-								/**
-		 * The meta object literal for the '<em><b>After</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference ORDERING_TYPE__AFTER = eINSTANCE.getOrderingType_After();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.OrderingOrderingTypeImpl <em>Ordering Ordering Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.OrderingOrderingTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getOrderingOrderingType()
-		 * @generated
-		 */
-		EClass ORDERING_ORDERING_TYPE = eINSTANCE.getOrderingOrderingType();
-
-								/**
-		 * The meta object literal for the '<em><b>Name</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference ORDERING_ORDERING_TYPE__NAME = eINSTANCE.getOrderingOrderingType_Name();
-
-								/**
-		 * The meta object literal for the '<em><b>Others</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference ORDERING_ORDERING_TYPE__OTHERS = eINSTANCE.getOrderingOrderingType_Others();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.OrderingOthersTypeImpl <em>Ordering Others Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.OrderingOthersTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getOrderingOthersType()
-		 * @generated
-		 */
-		EClass ORDERING_OTHERS_TYPE = eINSTANCE.getOrderingOthersType();
-
-								/**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute ORDERING_OTHERS_TYPE__ID = eINSTANCE.getOrderingOthersType_Id();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PartialViewContextFactoryTypeImpl <em>Partial View Context Factory Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.PartialViewContextFactoryTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getPartialViewContextFactoryType()
-		 * @generated
-		 */
-		EClass PARTIAL_VIEW_CONTEXT_FACTORY_TYPE = eINSTANCE.getPartialViewContextFactoryType();
-
-								/**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute PARTIAL_VIEW_CONTEXT_FACTORY_TYPE__TEXT_CONTENT = eINSTANCE.getPartialViewContextFactoryType_TextContent();
-
-								/**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute PARTIAL_VIEW_CONTEXT_FACTORY_TYPE__ID = eINSTANCE.getPartialViewContextFactoryType_Id();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PhaseListenerTypeImpl <em>Phase Listener Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.PhaseListenerTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getPhaseListenerType()
-		 * @generated
-		 */
-        EClass PHASE_LISTENER_TYPE = eINSTANCE.getPhaseListenerType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute PHASE_LISTENER_TYPE__TEXT_CONTENT = eINSTANCE.getPhaseListenerType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute PHASE_LISTENER_TYPE__ID = eINSTANCE.getPhaseListenerType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyClassTypeImpl <em>Property Class Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyClassTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getPropertyClassType()
-		 * @generated
-		 */
-        EClass PROPERTY_CLASS_TYPE = eINSTANCE.getPropertyClassType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute PROPERTY_CLASS_TYPE__TEXT_CONTENT = eINSTANCE.getPropertyClassType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute PROPERTY_CLASS_TYPE__ID = eINSTANCE.getPropertyClassType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyExtensionTypeImpl <em>Property Extension Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyExtensionTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getPropertyExtensionType()
-		 * @generated
-		 */
-        EClass PROPERTY_EXTENSION_TYPE = eINSTANCE.getPropertyExtensionType();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyNameTypeImpl <em>Property Name Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyNameTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getPropertyNameType()
-		 * @generated
-		 */
-        EClass PROPERTY_NAME_TYPE = eINSTANCE.getPropertyNameType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute PROPERTY_NAME_TYPE__TEXT_CONTENT = eINSTANCE.getPropertyNameType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute PROPERTY_NAME_TYPE__ID = eINSTANCE.getPropertyNameType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyResolverTypeImpl <em>Property Resolver Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyResolverTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getPropertyResolverType()
-		 * @generated
-		 */
-        EClass PROPERTY_RESOLVER_TYPE = eINSTANCE.getPropertyResolverType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute PROPERTY_RESOLVER_TYPE__TEXT_CONTENT = eINSTANCE.getPropertyResolverType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute PROPERTY_RESOLVER_TYPE__ID = eINSTANCE.getPropertyResolverType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyTypeImpl <em>Property Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getPropertyType()
-		 * @generated
-		 */
-        EClass PROPERTY_TYPE = eINSTANCE.getPropertyType();
-
-        /**
-		 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference PROPERTY_TYPE__DESCRIPTION = eINSTANCE.getPropertyType_Description();
-
-        /**
-		 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference PROPERTY_TYPE__DISPLAY_NAME = eINSTANCE.getPropertyType_DisplayName();
-
-        /**
-		 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference PROPERTY_TYPE__ICON = eINSTANCE.getPropertyType_Icon();
-
-        /**
-		 * The meta object literal for the '<em><b>Property Name</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference PROPERTY_TYPE__PROPERTY_NAME = eINSTANCE.getPropertyType_PropertyName();
-
-        /**
-		 * The meta object literal for the '<em><b>Property Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference PROPERTY_TYPE__PROPERTY_CLASS = eINSTANCE.getPropertyType_PropertyClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Default Value</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference PROPERTY_TYPE__DEFAULT_VALUE = eINSTANCE.getPropertyType_DefaultValue();
-
-        /**
-		 * The meta object literal for the '<em><b>Suggested Value</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference PROPERTY_TYPE__SUGGESTED_VALUE = eINSTANCE.getPropertyType_SuggestedValue();
-
-        /**
-		 * The meta object literal for the '<em><b>Property Extension</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference PROPERTY_TYPE__PROPERTY_EXTENSION = eINSTANCE.getPropertyType_PropertyExtension();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute PROPERTY_TYPE__ID = eINSTANCE.getPropertyType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RedirectTypeImpl <em>Redirect Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RedirectTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRedirectType()
-		 * @generated
-		 */
-        EClass REDIRECT_TYPE = eINSTANCE.getRedirectType();
-
-        /**
-		 * The meta object literal for the '<em><b>View Param</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference REDIRECT_TYPE__VIEW_PARAM = eINSTANCE.getRedirectType_ViewParam();
-
-								/**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute REDIRECT_TYPE__ID = eINSTANCE.getRedirectType_Id();
-
-        /**
-		 * The meta object literal for the '<em><b>Include View Params</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute REDIRECT_TYPE__INCLUDE_VIEW_PARAMS = eINSTANCE.getRedirectType_IncludeViewParams();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RedirectViewParamTypeImpl <em>Redirect View Param Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RedirectViewParamTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRedirectViewParamType()
-		 * @generated
-		 */
-		EClass REDIRECT_VIEW_PARAM_TYPE = eINSTANCE.getRedirectViewParamType();
-
-								/**
-		 * The meta object literal for the '<em><b>Name</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference REDIRECT_VIEW_PARAM_TYPE__NAME = eINSTANCE.getRedirectViewParamType_Name();
-
-								/**
-		 * The meta object literal for the '<em><b>Value</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference REDIRECT_VIEW_PARAM_TYPE__VALUE = eINSTANCE.getRedirectViewParamType_Value();
-
-								/**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute REDIRECT_VIEW_PARAM_TYPE__ID = eINSTANCE.getRedirectViewParamType_Id();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanClassTypeImpl <em>Referenced Bean Class Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanClassTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getReferencedBeanClassType()
-		 * @generated
-		 */
-        EClass REFERENCED_BEAN_CLASS_TYPE = eINSTANCE.getReferencedBeanClassType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute REFERENCED_BEAN_CLASS_TYPE__TEXT_CONTENT = eINSTANCE.getReferencedBeanClassType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute REFERENCED_BEAN_CLASS_TYPE__ID = eINSTANCE.getReferencedBeanClassType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanNameTypeImpl <em>Referenced Bean Name Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanNameTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getReferencedBeanNameType()
-		 * @generated
-		 */
-        EClass REFERENCED_BEAN_NAME_TYPE = eINSTANCE.getReferencedBeanNameType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute REFERENCED_BEAN_NAME_TYPE__TEXT_CONTENT = eINSTANCE.getReferencedBeanNameType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute REFERENCED_BEAN_NAME_TYPE__ID = eINSTANCE.getReferencedBeanNameType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanTypeImpl <em>Referenced Bean Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getReferencedBeanType()
-		 * @generated
-		 */
-        EClass REFERENCED_BEAN_TYPE = eINSTANCE.getReferencedBeanType();
-
-        /**
-		 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference REFERENCED_BEAN_TYPE__DESCRIPTION = eINSTANCE.getReferencedBeanType_Description();
-
-        /**
-		 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference REFERENCED_BEAN_TYPE__DISPLAY_NAME = eINSTANCE.getReferencedBeanType_DisplayName();
-
-        /**
-		 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference REFERENCED_BEAN_TYPE__ICON = eINSTANCE.getReferencedBeanType_Icon();
-
-        /**
-		 * The meta object literal for the '<em><b>Referenced Bean Name</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference REFERENCED_BEAN_TYPE__REFERENCED_BEAN_NAME = eINSTANCE.getReferencedBeanType_ReferencedBeanName();
-
-        /**
-		 * The meta object literal for the '<em><b>Referenced Bean Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference REFERENCED_BEAN_TYPE__REFERENCED_BEAN_CLASS = eINSTANCE.getReferencedBeanType_ReferencedBeanClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute REFERENCED_BEAN_TYPE__ID = eINSTANCE.getReferencedBeanType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererClassTypeImpl <em>Renderer Class Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RendererClassTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRendererClassType()
-		 * @generated
-		 */
-        EClass RENDERER_CLASS_TYPE = eINSTANCE.getRendererClassType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute RENDERER_CLASS_TYPE__TEXT_CONTENT = eINSTANCE.getRendererClassType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute RENDERER_CLASS_TYPE__ID = eINSTANCE.getRendererClassType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererExtensionTypeImpl <em>Renderer Extension Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RendererExtensionTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRendererExtensionType()
-		 * @generated
-		 */
-        EClass RENDERER_EXTENSION_TYPE = eINSTANCE.getRendererExtensionType();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeImpl <em>Renderer Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRendererType()
-		 * @generated
-		 */
-        EClass RENDERER_TYPE = eINSTANCE.getRendererType();
-
-        /**
-		 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference RENDERER_TYPE__DESCRIPTION = eINSTANCE.getRendererType_Description();
-
-        /**
-		 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference RENDERER_TYPE__DISPLAY_NAME = eINSTANCE.getRendererType_DisplayName();
-
-        /**
-		 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference RENDERER_TYPE__ICON = eINSTANCE.getRendererType_Icon();
-
-        /**
-		 * The meta object literal for the '<em><b>Component Family</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference RENDERER_TYPE__COMPONENT_FAMILY = eINSTANCE.getRendererType_ComponentFamily();
-
-        /**
-		 * The meta object literal for the '<em><b>Renderer Type</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference RENDERER_TYPE__RENDERER_TYPE = eINSTANCE.getRendererType_RendererType();
-
-        /**
-		 * The meta object literal for the '<em><b>Renderer Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference RENDERER_TYPE__RENDERER_CLASS = eINSTANCE.getRendererType_RendererClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Facet</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference RENDERER_TYPE__FACET = eINSTANCE.getRendererType_Facet();
-
-        /**
-		 * The meta object literal for the '<em><b>Attribute</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference RENDERER_TYPE__ATTRIBUTE = eINSTANCE.getRendererType_Attribute();
-
-        /**
-		 * The meta object literal for the '<em><b>Renderer Extension</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference RENDERER_TYPE__RENDERER_EXTENSION = eINSTANCE.getRendererType_RendererExtension();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute RENDERER_TYPE__ID = eINSTANCE.getRendererType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeTypeImpl <em>Renderer Type Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRendererTypeType()
-		 * @generated
-		 */
-        EClass RENDERER_TYPE_TYPE = eINSTANCE.getRendererTypeType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute RENDERER_TYPE_TYPE__TEXT_CONTENT = eINSTANCE.getRendererTypeType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute RENDERER_TYPE_TYPE__ID = eINSTANCE.getRendererTypeType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitClassTypeImpl <em>Render Kit Class Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitClassTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRenderKitClassType()
-		 * @generated
-		 */
-        EClass RENDER_KIT_CLASS_TYPE = eINSTANCE.getRenderKitClassType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute RENDER_KIT_CLASS_TYPE__TEXT_CONTENT = eINSTANCE.getRenderKitClassType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute RENDER_KIT_CLASS_TYPE__ID = eINSTANCE.getRenderKitClassType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitFactoryTypeImpl <em>Render Kit Factory Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitFactoryTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRenderKitFactoryType()
-		 * @generated
-		 */
-        EClass RENDER_KIT_FACTORY_TYPE = eINSTANCE.getRenderKitFactoryType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute RENDER_KIT_FACTORY_TYPE__TEXT_CONTENT = eINSTANCE.getRenderKitFactoryType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute RENDER_KIT_FACTORY_TYPE__ID = eINSTANCE.getRenderKitFactoryType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitIdTypeImpl <em>Render Kit Id Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitIdTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRenderKitIdType()
-		 * @generated
-		 */
-        EClass RENDER_KIT_ID_TYPE = eINSTANCE.getRenderKitIdType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute RENDER_KIT_ID_TYPE__TEXT_CONTENT = eINSTANCE.getRenderKitIdType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute RENDER_KIT_ID_TYPE__ID = eINSTANCE.getRenderKitIdType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitTypeImpl <em>Render Kit Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRenderKitType()
-		 * @generated
-		 */
-        EClass RENDER_KIT_TYPE = eINSTANCE.getRenderKitType();
-
-        /**
-		 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference RENDER_KIT_TYPE__DESCRIPTION = eINSTANCE.getRenderKitType_Description();
-
-        /**
-		 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference RENDER_KIT_TYPE__DISPLAY_NAME = eINSTANCE.getRenderKitType_DisplayName();
-
-        /**
-		 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference RENDER_KIT_TYPE__ICON = eINSTANCE.getRenderKitType_Icon();
-
-        /**
-		 * The meta object literal for the '<em><b>Render Kit Id</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference RENDER_KIT_TYPE__RENDER_KIT_ID = eINSTANCE.getRenderKitType_RenderKitId();
-
-        /**
-		 * The meta object literal for the '<em><b>Render Kit Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference RENDER_KIT_TYPE__RENDER_KIT_CLASS = eINSTANCE.getRenderKitType_RenderKitClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Renderer</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference RENDER_KIT_TYPE__RENDERER = eINSTANCE.getRenderKitType_Renderer();
-
-        /**
-		 * The meta object literal for the '<em><b>Client Behavior Renderer</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference RENDER_KIT_TYPE__CLIENT_BEHAVIOR_RENDERER = eINSTANCE.getRenderKitType_ClientBehaviorRenderer();
-
-								/**
-		 * The meta object literal for the '<em><b>Render Kit Extension</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference RENDER_KIT_TYPE__RENDER_KIT_EXTENSION = eINSTANCE.getRenderKitType_RenderKitExtension();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute RENDER_KIT_TYPE__ID = eINSTANCE.getRenderKitType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SmallIconTypeImpl <em>Small Icon Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.SmallIconTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getSmallIconType()
-		 * @generated
-		 */
-        EClass SMALL_ICON_TYPE = eINSTANCE.getSmallIconType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute SMALL_ICON_TYPE__TEXT_CONTENT = eINSTANCE.getSmallIconType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute SMALL_ICON_TYPE__ID = eINSTANCE.getSmallIconType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SourceClassTypeImpl <em>Source Class Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.SourceClassTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getSourceClassType()
-		 * @generated
-		 */
-		EClass SOURCE_CLASS_TYPE = eINSTANCE.getSourceClassType();
-
-								/**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute SOURCE_CLASS_TYPE__TEXT_CONTENT = eINSTANCE.getSourceClassType_TextContent();
-
-								/**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute SOURCE_CLASS_TYPE__ID = eINSTANCE.getSourceClassType_Id();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.StateManagerTypeImpl <em>State Manager Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.StateManagerTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getStateManagerType()
-		 * @generated
-		 */
-        EClass STATE_MANAGER_TYPE = eINSTANCE.getStateManagerType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute STATE_MANAGER_TYPE__TEXT_CONTENT = eINSTANCE.getStateManagerType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute STATE_MANAGER_TYPE__ID = eINSTANCE.getStateManagerType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SuggestedValueTypeImpl <em>Suggested Value Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.SuggestedValueTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getSuggestedValueType()
-		 * @generated
-		 */
-        EClass SUGGESTED_VALUE_TYPE = eINSTANCE.getSuggestedValueType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute SUGGESTED_VALUE_TYPE__TEXT_CONTENT = eINSTANCE.getSuggestedValueType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute SUGGESTED_VALUE_TYPE__ID = eINSTANCE.getSuggestedValueType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SupportedLocaleTypeImpl <em>Supported Locale Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.SupportedLocaleTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getSupportedLocaleType()
-		 * @generated
-		 */
-        EClass SUPPORTED_LOCALE_TYPE = eINSTANCE.getSupportedLocaleType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute SUPPORTED_LOCALE_TYPE__TEXT_CONTENT = eINSTANCE.getSupportedLocaleType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute SUPPORTED_LOCALE_TYPE__ID = eINSTANCE.getSupportedLocaleType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SystemEventClassTypeImpl <em>System Event Class Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.SystemEventClassTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getSystemEventClassType()
-		 * @generated
-		 */
-		EClass SYSTEM_EVENT_CLASS_TYPE = eINSTANCE.getSystemEventClassType();
-
-								/**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute SYSTEM_EVENT_CLASS_TYPE__TEXT_CONTENT = eINSTANCE.getSystemEventClassType_TextContent();
-
-								/**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute SYSTEM_EVENT_CLASS_TYPE__ID = eINSTANCE.getSystemEventClassType_Id();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SystemEventListenerClassTypeImpl <em>System Event Listener Class Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.SystemEventListenerClassTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getSystemEventListenerClassType()
-		 * @generated
-		 */
-		EClass SYSTEM_EVENT_LISTENER_CLASS_TYPE = eINSTANCE.getSystemEventListenerClassType();
-
-								/**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute SYSTEM_EVENT_LISTENER_CLASS_TYPE__TEXT_CONTENT = eINSTANCE.getSystemEventListenerClassType_TextContent();
-
-								/**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute SYSTEM_EVENT_LISTENER_CLASS_TYPE__ID = eINSTANCE.getSystemEventListenerClassType_Id();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SystemEventListenerTypeImpl <em>System Event Listener Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.SystemEventListenerTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getSystemEventListenerType()
-		 * @generated
-		 */
-		EClass SYSTEM_EVENT_LISTENER_TYPE = eINSTANCE.getSystemEventListenerType();
-
-								/**
-		 * The meta object literal for the '<em><b>System Event Listener Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_LISTENER_CLASS = eINSTANCE.getSystemEventListenerType_SystemEventListenerClass();
-
-								/**
-		 * The meta object literal for the '<em><b>System Event Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_CLASS = eINSTANCE.getSystemEventListenerType_SystemEventClass();
-
-								/**
-		 * The meta object literal for the '<em><b>Source Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference SYSTEM_EVENT_LISTENER_TYPE__SOURCE_CLASS = eINSTANCE.getSystemEventListenerType_SourceClass();
-
-								/**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute SYSTEM_EVENT_LISTENER_TYPE__ID = eINSTANCE.getSystemEventListenerType_Id();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.TagHandlerDelegateFactoryTypeImpl <em>Tag Handler Delegate Factory Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.TagHandlerDelegateFactoryTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getTagHandlerDelegateFactoryType()
-		 * @generated
-		 */
-		EClass TAG_HANDLER_DELEGATE_FACTORY_TYPE = eINSTANCE.getTagHandlerDelegateFactoryType();
-
-								/**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute TAG_HANDLER_DELEGATE_FACTORY_TYPE__TEXT_CONTENT = eINSTANCE.getTagHandlerDelegateFactoryType_TextContent();
-
-								/**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute TAG_HANDLER_DELEGATE_FACTORY_TYPE__ID = eINSTANCE.getTagHandlerDelegateFactoryType_Id();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ToViewIdTypeImpl <em>To View Id Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ToViewIdTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getToViewIdType()
-		 * @generated
-		 */
-        EClass TO_VIEW_ID_TYPE = eINSTANCE.getToViewIdType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute TO_VIEW_ID_TYPE__TEXT_CONTENT = eINSTANCE.getToViewIdType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute TO_VIEW_ID_TYPE__ID = eINSTANCE.getToViewIdType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorClassTypeImpl <em>Validator Class Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorClassTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getValidatorClassType()
-		 * @generated
-		 */
-        EClass VALIDATOR_CLASS_TYPE = eINSTANCE.getValidatorClassType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute VALIDATOR_CLASS_TYPE__TEXT_CONTENT = eINSTANCE.getValidatorClassType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute VALIDATOR_CLASS_TYPE__ID = eINSTANCE.getValidatorClassType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorIdTypeImpl <em>Validator Id Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorIdTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getValidatorIdType()
-		 * @generated
-		 */
-        EClass VALIDATOR_ID_TYPE = eINSTANCE.getValidatorIdType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute VALIDATOR_ID_TYPE__TEXT_CONTENT = eINSTANCE.getValidatorIdType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute VALIDATOR_ID_TYPE__ID = eINSTANCE.getValidatorIdType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorTypeImpl <em>Validator Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getValidatorType()
-		 * @generated
-		 */
-        EClass VALIDATOR_TYPE = eINSTANCE.getValidatorType();
-
-        /**
-		 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference VALIDATOR_TYPE__DESCRIPTION = eINSTANCE.getValidatorType_Description();
-
-        /**
-		 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference VALIDATOR_TYPE__DISPLAY_NAME = eINSTANCE.getValidatorType_DisplayName();
-
-        /**
-		 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference VALIDATOR_TYPE__ICON = eINSTANCE.getValidatorType_Icon();
-
-        /**
-		 * The meta object literal for the '<em><b>Validator Id</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference VALIDATOR_TYPE__VALIDATOR_ID = eINSTANCE.getValidatorType_ValidatorId();
-
-        /**
-		 * The meta object literal for the '<em><b>Validator Class</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference VALIDATOR_TYPE__VALIDATOR_CLASS = eINSTANCE.getValidatorType_ValidatorClass();
-
-        /**
-		 * The meta object literal for the '<em><b>Attribute</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference VALIDATOR_TYPE__ATTRIBUTE = eINSTANCE.getValidatorType_Attribute();
-
-        /**
-		 * The meta object literal for the '<em><b>Property</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference VALIDATOR_TYPE__PROPERTY = eINSTANCE.getValidatorType_Property();
-
-        /**
-		 * The meta object literal for the '<em><b>Validator Extension</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference VALIDATOR_TYPE__VALIDATOR_EXTENSION = eINSTANCE.getValidatorType_ValidatorExtension();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute VALIDATOR_TYPE__ID = eINSTANCE.getValidatorType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValueClassTypeImpl <em>Value Class Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ValueClassTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getValueClassType()
-		 * @generated
-		 */
-        EClass VALUE_CLASS_TYPE = eINSTANCE.getValueClassType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute VALUE_CLASS_TYPE__TEXT_CONTENT = eINSTANCE.getValueClassType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute VALUE_CLASS_TYPE__ID = eINSTANCE.getValueClassType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValueTypeImpl <em>Value Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ValueTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getValueType()
-		 * @generated
-		 */
-        EClass VALUE_TYPE = eINSTANCE.getValueType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute VALUE_TYPE__TEXT_CONTENT = eINSTANCE.getValueType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute VALUE_TYPE__ID = eINSTANCE.getValueType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.VariableResolverTypeImpl <em>Variable Resolver Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.VariableResolverTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getVariableResolverType()
-		 * @generated
-		 */
-        EClass VARIABLE_RESOLVER_TYPE = eINSTANCE.getVariableResolverType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute VARIABLE_RESOLVER_TYPE__TEXT_CONTENT = eINSTANCE.getVariableResolverType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute VARIABLE_RESOLVER_TYPE__ID = eINSTANCE.getVariableResolverType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ViewHandlerTypeImpl <em>View Handler Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ViewHandlerTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getViewHandlerType()
-		 * @generated
-		 */
-        EClass VIEW_HANDLER_TYPE = eINSTANCE.getViewHandlerType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute VIEW_HANDLER_TYPE__TEXT_CONTENT = eINSTANCE.getViewHandlerType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute VIEW_HANDLER_TYPE__ID = eINSTANCE.getViewHandlerType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ResourceBundleTypeImpl <em>Resource Bundle Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ResourceBundleTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getResourceBundleType()
-		 * @generated
-		 */
-        EClass RESOURCE_BUNDLE_TYPE = eINSTANCE.getResourceBundleType();
-
-        /**
-		 * The meta object literal for the '<em><b>Description</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference RESOURCE_BUNDLE_TYPE__DESCRIPTION = eINSTANCE.getResourceBundleType_Description();
-
-        /**
-		 * The meta object literal for the '<em><b>Display Name</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference RESOURCE_BUNDLE_TYPE__DISPLAY_NAME = eINSTANCE.getResourceBundleType_DisplayName();
-
-        /**
-		 * The meta object literal for the '<em><b>Icon</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference RESOURCE_BUNDLE_TYPE__ICON = eINSTANCE.getResourceBundleType_Icon();
-
-        /**
-		 * The meta object literal for the '<em><b>Base Name</b></em>' reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference RESOURCE_BUNDLE_TYPE__BASE_NAME = eINSTANCE.getResourceBundleType_BaseName();
-
-        /**
-		 * The meta object literal for the '<em><b>Var</b></em>' reference feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference RESOURCE_BUNDLE_TYPE__VAR = eINSTANCE.getResourceBundleType_Var();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute RESOURCE_BUNDLE_TYPE__ID = eINSTANCE.getResourceBundleType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BaseNameTypeImpl <em>Base Name Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.BaseNameTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getBaseNameType()
-		 * @generated
-		 */
-        EClass BASE_NAME_TYPE = eINSTANCE.getBaseNameType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute BASE_NAME_TYPE__TEXT_CONTENT = eINSTANCE.getBaseNameType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute BASE_NAME_TYPE__ID = eINSTANCE.getBaseNameType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.VarTypeImpl <em>Var Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.VarTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getVarType()
-		 * @generated
-		 */
-        EClass VAR_TYPE = eINSTANCE.getVarType();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute VAR_TYPE__TEXT_CONTENT = eINSTANCE.getVarType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute VAR_TYPE__ID = eINSTANCE.getVarType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ViewDeclarationLanguageFactoryTypeImpl <em>View Declaration Language Factory Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ViewDeclarationLanguageFactoryTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getViewDeclarationLanguageFactoryType()
-		 * @generated
-		 */
-		EClass VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE = eINSTANCE.getViewDeclarationLanguageFactoryType();
-
-								/**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE__TEXT_CONTENT = eINSTANCE.getViewDeclarationLanguageFactoryType_TextContent();
-
-								/**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE__ID = eINSTANCE.getViewDeclarationLanguageFactoryType_Id();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.VisitContextFactoryTypeImpl <em>Visit Context Factory Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.VisitContextFactoryTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getVisitContextFactoryType()
-		 * @generated
-		 */
-		EClass VISIT_CONTEXT_FACTORY_TYPE = eINSTANCE.getVisitContextFactoryType();
-
-								/**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute VISIT_CONTEXT_FACTORY_TYPE__TEXT_CONTENT = eINSTANCE.getVisitContextFactoryType_TextContent();
-
-								/**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute VISIT_CONTEXT_FACTORY_TYPE__ID = eINSTANCE.getVisitContextFactoryType_Id();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitExtensionTypeImpl <em>Render Kit Extension Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitExtensionTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getRenderKitExtensionType()
-		 * @generated
-		 */
-        EClass RENDER_KIT_EXTENSION_TYPE = eINSTANCE.getRenderKitExtensionType();
-
-            /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ResourceHandlerTypeImpl <em>Resource Handler Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ResourceHandlerTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getResourceHandlerType()
-		 * @generated
-		 */
-		EClass RESOURCE_HANDLER_TYPE = eINSTANCE.getResourceHandlerType();
-
-								/**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute RESOURCE_HANDLER_TYPE__TEXT_CONTENT = eINSTANCE.getResourceHandlerType_TextContent();
-
-								/**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute RESOURCE_HANDLER_TYPE__ID = eINSTANCE.getResourceHandlerType_Id();
-
-												/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationRuleExtensionTypeImpl <em>Navigation Rule Extension Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationRuleExtensionTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getNavigationRuleExtensionType()
-		 * @generated
-		 */
-        EClass NAVIGATION_RULE_EXTENSION_TYPE = eINSTANCE.getNavigationRuleExtensionType();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorExtensionTypeImpl <em>Validator Extension Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorExtensionTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getValidatorExtensionType()
-		 * @generated
-		 */
-        EClass VALIDATOR_EXTENSION_TYPE = eINSTANCE.getValidatorExtensionType();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigExtensionTypeImpl <em>Extension Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigExtensionTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFacesConfigExtensionType()
-		 * @generated
-		 */
-        EClass FACES_CONFIG_EXTENSION_TYPE = eINSTANCE.getFacesConfigExtensionType();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryExtensionTypeImpl <em>Factory Extension Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryExtensionTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getFactoryExtensionType()
-		 * @generated
-		 */
-        EClass FACTORY_EXTENSION_TYPE = eINSTANCE.getFactoryExtensionType();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LifecycleExtensionTypeImpl <em>Lifecycle Extension Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.LifecycleExtensionTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getLifecycleExtensionType()
-		 * @generated
-		 */
-        EClass LIFECYCLE_EXTENSION_TYPE = eINSTANCE.getLifecycleExtensionType();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanExtensionTypeImpl <em>Managed Bean Extension Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanExtensionTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getManagedBeanExtensionType()
-		 * @generated
-		 */
-        EClass MANAGED_BEAN_EXTENSION_TYPE = eINSTANCE.getManagedBeanExtensionType();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterExtensionTypeImpl <em>Converter Extension Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterExtensionTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getConverterExtensionType()
-		 * @generated
-		 */
-        EClass CONVERTER_EXTENSION_TYPE = eINSTANCE.getConverterExtensionType();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ExtensionTypeImpl <em>Extension Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ExtensionTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getExtensionType()
-		 * @generated
-		 */
-        EClass EXTENSION_TYPE = eINSTANCE.getExtensionType();
-
-        /**
-		 * The meta object literal for the '<em><b>Child Nodes</b></em>' reference list feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EReference EXTENSION_TYPE__CHILD_NODES = eINSTANCE.getExtensionType_ChildNodes();
-
-        /**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute EXTENSION_TYPE__TEXT_CONTENT = eINSTANCE.getExtensionType_TextContent();
-
-        /**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @generated
-		 */
-        EAttribute EXTENSION_TYPE__ID = eINSTANCE.getExtensionType_Id();
-
-        /**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ExternalContextFactoryTypeImpl <em>External Context Factory Type</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ExternalContextFactoryTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getExternalContextFactoryType()
-		 * @generated
-		 */
-		EClass EXTERNAL_CONTEXT_FACTORY_TYPE = eINSTANCE.getExternalContextFactoryType();
-
-								/**
-		 * The meta object literal for the '<em><b>Text Content</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute EXTERNAL_CONTEXT_FACTORY_TYPE__TEXT_CONTENT = eINSTANCE.getExternalContextFactoryType_TextContent();
-
-								/**
-		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute EXTERNAL_CONTEXT_FACTORY_TYPE__ID = eINSTANCE.getExternalContextFactoryType_Id();
-
-								/**
-		 * The meta object literal for the '{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationExtensionTypeImpl <em>Application Extension Type</em>}' class.
-		 * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationExtensionTypeImpl
-		 * @see org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigPackageImpl#getApplicationExtensionType()
-		 * @generated
-		 */
-        EClass APPLICATION_EXTENSION_TYPE = eINSTANCE.getApplicationExtensionType();
-
-}
-
-} //FacesConfigPackage
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacesConfigType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacesConfigType.java
deleted file mode 100644
index 825bac3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacesConfigType.java
+++ /dev/null
@@ -1,442 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getApplication <em>Application</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getOrdering <em>Ordering</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getAbsoluteOrdering <em>Absolute Ordering</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getFactory <em>Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getComponent <em>Component</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getConverter <em>Converter</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getManagedBean <em>Managed Bean</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getNavigationRule <em>Navigation Rule</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getReferencedBean <em>Referenced Bean</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getRenderKit <em>Render Kit</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getLifecycle <em>Lifecycle</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getValidator <em>Validator</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getBehavior <em>Behavior</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getFacesConfigExtension <em>Faces Config Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getXmlns <em>Xmlns</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getId <em>Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#isMetadataComplete <em>Metadata Complete</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesConfigType()
- * @model extendedMetaData="name='faces-config_._type' kind='elementOnly'"
- * @generated
- */
-public interface FacesConfigType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Application</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Application</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>Application</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesConfigType_Application()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ApplicationType" containment="true"
-	 *        extendedMetaData="kind='element' name='application' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getApplication();
-
-    /**
-	 * Returns the value of the '<em><b>Ordering</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.OrderingType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Ordering</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>Ordering</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesConfigType_Ordering()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.OrderingType" containment="true"
-	 *        extendedMetaData="kind='element' name='ordering' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getOrdering();
-
-				/**
-	 * Returns the value of the '<em><b>Absolute Ordering</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Absolute Ordering</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Absolute Ordering</em>' containment reference.
-	 * @see #setAbsoluteOrdering(AbsoluteOrderingType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesConfigType_AbsoluteOrdering()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='absolute-ordering' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	AbsoluteOrderingType getAbsoluteOrdering();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getAbsoluteOrdering <em>Absolute Ordering</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Absolute Ordering</em>' containment reference.
-	 * @see #getAbsoluteOrdering()
-	 * @generated
-	 */
-	void setAbsoluteOrdering(AbsoluteOrderingType value);
-
-				/**
-	 * Returns the value of the '<em><b>Factory</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Factory</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>Factory</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesConfigType_Factory()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.FactoryType" containment="true"
-	 *        extendedMetaData="kind='element' name='factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getFactory();
-
-    /**
-	 * Returns the value of the '<em><b>Component</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Component</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>Component</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesConfigType_Component()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ComponentType" containment="true"
-	 *        extendedMetaData="kind='element' name='component' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getComponent();
-
-    /**
-	 * Returns the value of the '<em><b>Converter</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Converter</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>Converter</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesConfigType_Converter()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ConverterType" containment="true"
-	 *        extendedMetaData="kind='element' name='converter' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getConverter();
-
-    /**
-	 * Returns the value of the '<em><b>Managed Bean</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Managed Bean</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>Managed Bean</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesConfigType_ManagedBean()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType" containment="true"
-	 *        extendedMetaData="kind='element' name='managed-bean' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getManagedBean();
-
-    /**
-	 * Returns the value of the '<em><b>Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Name</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Name</em>' containment reference.
-	 * @see #setName(NameType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesConfigType_Name()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	NameType getName();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getName <em>Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Name</em>' containment reference.
-	 * @see #getName()
-	 * @generated
-	 */
-	void setName(NameType value);
-
-				/**
-	 * Returns the value of the '<em><b>Navigation Rule</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Navigation Rule</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>Navigation Rule</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesConfigType_NavigationRule()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType" containment="true"
-	 *        extendedMetaData="kind='element' name='navigation-rule' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getNavigationRule();
-
-    /**
-	 * Returns the value of the '<em><b>Referenced Bean</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Referenced Bean</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>Referenced Bean</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesConfigType_ReferencedBean()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType" containment="true"
-	 *        extendedMetaData="kind='element' name='referenced-bean' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getReferencedBean();
-
-    /**
-	 * Returns the value of the '<em><b>Render Kit</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Render Kit</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>Render Kit</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesConfigType_RenderKit()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.RenderKitType" containment="true"
-	 *        extendedMetaData="kind='element' name='render-kit' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getRenderKit();
-
-    /**
-	 * Returns the value of the '<em><b>Lifecycle</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Lifecycle</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>Lifecycle</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesConfigType_Lifecycle()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.LifecycleType" containment="true"
-	 *        extendedMetaData="kind='element' name='lifecycle' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getLifecycle();
-
-    /**
-	 * Returns the value of the '<em><b>Validator</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Validator</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>Validator</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesConfigType_Validator()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ValidatorType" containment="true"
-	 *        extendedMetaData="kind='element' name='validator' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getValidator();
-
-    /**
-	 * Returns the value of the '<em><b>Behavior</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Behavior</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>Behavior</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesConfigType_Behavior()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.BehaviorType" containment="true"
-	 *        extendedMetaData="kind='element' name='behavior' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getBehavior();
-
-				/**
-	 * Returns the value of the '<em><b>Faces Config Extension</b></em>' reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigExtensionType}.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Faces Config Extension</em>' reference list isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-	 * @return the value of the '<em>Faces Config Extension</em>' reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesConfigType_FacesConfigExtension()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.FacesConfigExtensionType"
-	 *        extendedMetaData="kind='element' name='faces-config-extension' namespace='##targetNamespace'"
-	 * @generated
-	 */
-    EList getFacesConfigExtension();
-
-    /**
-	 * Returns the value of the '<em><b>Xmlns</b></em>' attribute.
-	 * The default value is <code>"http://java.sun.com/JSF/Configuration"</code>.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Xmlns</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Xmlns</em>' attribute.
-	 * @see #isSetXmlns()
-	 * @see #unsetXmlns()
-	 * @see #setXmlns(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesConfigType_Xmlns()
-	 * @model default="http://java.sun.com/JSF/Configuration" unique="false" unsettable="true" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="kind='attribute' name='xmlns' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getXmlns();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getXmlns <em>Xmlns</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Xmlns</em>' attribute.
-	 * @see #isSetXmlns()
-	 * @see #unsetXmlns()
-	 * @see #getXmlns()
-	 * @generated
-	 */
-	void setXmlns(String value);
-
-    /**
-	 * Unsets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getXmlns <em>Xmlns</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetXmlns()
-	 * @see #getXmlns()
-	 * @see #setXmlns(String)
-	 * @generated
-	 */
-	void unsetXmlns();
-
-    /**
-	 * Returns whether the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getXmlns <em>Xmlns</em>}' attribute is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Xmlns</em>' attribute is set.
-	 * @see #unsetXmlns()
-	 * @see #getXmlns()
-	 * @see #setXmlns(String)
-	 * @generated
-	 */
-	boolean isSetXmlns();
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesConfigType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-				/**
-	 * Returns the value of the '<em><b>Metadata Complete</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Metadata Complete</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Metadata Complete</em>' attribute.
-	 * @see #setMetadataComplete(boolean)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesConfigType_MetadataComplete()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.Boolean"
-	 *        extendedMetaData="kind='attribute' name='metadata-complete' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	boolean isMetadataComplete();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType#isMetadataComplete <em>Metadata Complete</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Metadata Complete</em>' attribute.
-	 * @see #isMetadataComplete()
-	 * @generated
-	 */
-	void setMetadataComplete(boolean value);
-
-} // FacesConfigType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacesContextFactoryType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacesContextFactoryType.java
deleted file mode 100644
index a520c01..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacesContextFactoryType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Faces Context Factory Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacesContextFactoryType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacesContextFactoryType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesContextFactoryType()
- * @model extendedMetaData="name='faces-context-factory_._type' kind='simple'"
- * @generated
- */
-public interface FacesContextFactoryType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesContextFactoryType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesContextFactoryType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacesContextFactoryType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesContextFactoryType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // FacesContextFactoryType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacetExtensionType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacetExtensionType.java
deleted file mode 100644
index 9f7d387..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacetExtensionType.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Facet Extension Type</b></em>'.
- * <!-- end-user-doc -->
- *
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacetExtensionType()
- * @model extendedMetaData="name='facet-extension_._type'"
- * @generated
- */
-public interface FacetExtensionType extends ExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-} // FacetExtensionType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacetNameType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacetNameType.java
deleted file mode 100644
index 5732733..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacetNameType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Facet Name Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacetNameType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacetNameType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacetNameType()
- * @model extendedMetaData="name='facet-name_._type' kind='simple'"
- * @generated
- */
-public interface FacetNameType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacetNameType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.FacetNameType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacetNameType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.FacetNameType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // FacetNameType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacetType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacetType.java
deleted file mode 100644
index 9cb62f3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FacetType.java
+++ /dev/null
@@ -1,168 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Facet Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacetType#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacetType#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacetType#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacetType#getFacetName <em>Facet Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacetType#getFacetExtension <em>Facet Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FacetType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacetType()
- * @model extendedMetaData="name='facet_._type' kind='elementOnly'"
- * @generated
- */
-public interface FacetType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Description</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Description</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>Description</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacetType_Description()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DescriptionType" containment="true"
-	 *        extendedMetaData="kind='element' name='description' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDescription();
-
-    /**
-	 * Returns the value of the '<em><b>Display Name</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Display Name</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>Display Name</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacetType_DisplayName()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType" containment="true"
-	 *        extendedMetaData="kind='element' name='display-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDisplayName();
-
-    /**
-	 * Returns the value of the '<em><b>Icon</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.IconType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Icon</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>Icon</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacetType_Icon()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.IconType" containment="true"
-	 *        extendedMetaData="kind='element' name='icon' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getIcon();
-
-    /**
-	 * Returns the value of the '<em><b>Facet Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Facet Name</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Facet Name</em>' containment reference.
-	 * @see #setFacetName(FacetNameType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacetType_FacetName()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='facet-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	FacetNameType getFacetName();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.FacetType#getFacetName <em>Facet Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Facet Name</em>' containment reference.
-	 * @see #getFacetName()
-	 * @generated
-	 */
-	void setFacetName(FacetNameType value);
-
-    /**
-	 * Returns the value of the '<em><b>Facet Extension</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.FacetExtensionType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Facet Extension</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>Facet Extension</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacetType_FacetExtension()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.FacetExtensionType" containment="true"
-	 *        extendedMetaData="kind='element' name='facet-extension' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getFacetExtension();
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFacetType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.FacetType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // FacetType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FactoryExtensionType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FactoryExtensionType.java
deleted file mode 100644
index 67d67f5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FactoryExtensionType.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Factory Extension Type</b></em>'.
- * <!-- end-user-doc -->
- *
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFactoryExtensionType()
- * @model extendedMetaData="name='factory-extension_._type'"
- * @generated
- */
-public interface FactoryExtensionType extends ExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-} // FactoryExtensionType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FactoryType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FactoryType.java
deleted file mode 100644
index e2b9880..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FactoryType.java
+++ /dev/null
@@ -1,266 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Factory Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getApplicationFactory <em>Application Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getExceptionHandlerFactory <em>Exception Handler Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getExternalContextFactory <em>External Context Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getFacesContextFactory <em>Faces Context Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getPartialViewContextFactory <em>Partial View Context Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getLifecycleFactory <em>Lifecycle Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getViewDeclarationLanguageFactory <em>View Declaration Language Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getTagHandlerDelegateFactory <em>Tag Handler Delegate Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getRenderKitFactory <em>Render Kit Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getVisitContextFactory <em>Visit Context Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getFactoryExtension <em>Factory Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFactoryType()
- * @model extendedMetaData="name='factory_._type' kind='elementOnly'"
- * @generated
- */
-public interface FactoryType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Application Factory</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationFactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Application Factory</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>Application Factory</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFactoryType_ApplicationFactory()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ApplicationFactoryType" containment="true"
-	 *        extendedMetaData="kind='element' name='application-factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getApplicationFactory();
-
-    /**
-	 * Returns the value of the '<em><b>Exception Handler Factory</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ExceptionHandlerFactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Exception Handler Factory</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>Exception Handler Factory</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFactoryType_ExceptionHandlerFactory()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ExceptionHandlerFactoryType" containment="true"
-	 *        extendedMetaData="kind='element' name='exception-handler-factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getExceptionHandlerFactory();
-
-				/**
-	 * Returns the value of the '<em><b>External Context Factory</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ExternalContextFactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>External Context Factory</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>External Context Factory</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFactoryType_ExternalContextFactory()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ExternalContextFactoryType" containment="true"
-	 *        extendedMetaData="kind='element' name='external-context-factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getExternalContextFactory();
-
-				/**
-	 * Returns the value of the '<em><b>Faces Context Factory</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.FacesContextFactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Faces Context Factory</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>Faces Context Factory</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFactoryType_FacesContextFactory()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.FacesContextFactoryType" containment="true"
-	 *        extendedMetaData="kind='element' name='faces-context-factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getFacesContextFactory();
-
-    /**
-	 * Returns the value of the '<em><b>Partial View Context Factory</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.PartialViewContextFactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Partial View Context Factory</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>Partial View Context Factory</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFactoryType_PartialViewContextFactory()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.PartialViewContextFactoryType" containment="true"
-	 *        extendedMetaData="kind='element' name='partial-view-context-factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getPartialViewContextFactory();
-
-				/**
-	 * Returns the value of the '<em><b>Lifecycle Factory</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleFactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Lifecycle Factory</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>Lifecycle Factory</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFactoryType_LifecycleFactory()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.LifecycleFactoryType" containment="true"
-	 *        extendedMetaData="kind='element' name='lifecycle-factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getLifecycleFactory();
-
-    /**
-	 * Returns the value of the '<em><b>View Declaration Language Factory</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ViewDeclarationLanguageFactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>View Declaration Language Factory</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>View Declaration Language Factory</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFactoryType_ViewDeclarationLanguageFactory()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ViewDeclarationLanguageFactoryType" containment="true"
-	 *        extendedMetaData="kind='element' name='view-declaration-language-factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getViewDeclarationLanguageFactory();
-
-				/**
-	 * Returns the value of the '<em><b>Tag Handler Delegate Factory</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.TagHandlerDelegateFactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Tag Handler Delegate Factory</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>Tag Handler Delegate Factory</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFactoryType_TagHandlerDelegateFactory()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.TagHandlerDelegateFactoryType" containment="true"
-	 *        extendedMetaData="kind='element' name='tag-handler-delegate-factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getTagHandlerDelegateFactory();
-
-				/**
-	 * Returns the value of the '<em><b>Render Kit Factory</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitFactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Render Kit Factory</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>Render Kit Factory</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFactoryType_RenderKitFactory()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.RenderKitFactoryType" containment="true"
-	 *        extendedMetaData="kind='element' name='render-kit-factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getRenderKitFactory();
-
-    /**
-	 * Returns the value of the '<em><b>Visit Context Factory</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.VisitContextFactoryType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Visit Context Factory</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>Visit Context Factory</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFactoryType_VisitContextFactory()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.VisitContextFactoryType" containment="true"
-	 *        extendedMetaData="kind='element' name='visit-context-factory' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getVisitContextFactory();
-
-				/**
-	 * Returns the value of the '<em><b>Factory Extension</b></em>' reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.FactoryExtensionType}.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Factory Extension</em>' reference list isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-	 * @return the value of the '<em>Factory Extension</em>' reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFactoryType_FactoryExtension()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.FactoryExtensionType"
-	 *        extendedMetaData="kind='element' name='factory-type' namespace='##targetNamespace'"
-	 * @generated
-	 */
-    EList getFactoryExtension();
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFactoryType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // FactoryType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FromActionType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FromActionType.java
deleted file mode 100644
index e1db0f8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FromActionType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>From Action Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FromActionType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FromActionType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFromActionType()
- * @model extendedMetaData="name='from-action_._type' kind='simple'"
- * @generated
- */
-public interface FromActionType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFromActionType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.FromActionType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFromActionType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.FromActionType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // FromActionType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FromOutcomeType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FromOutcomeType.java
deleted file mode 100644
index 051d4ee..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FromOutcomeType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>From Outcome Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FromOutcomeType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FromOutcomeType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFromOutcomeType()
- * @model extendedMetaData="name='from-outcome_._type' kind='simple'"
- * @generated
- */
-public interface FromOutcomeType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFromOutcomeType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.FromOutcomeType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFromOutcomeType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.FromOutcomeType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // FromOutcomeType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FromViewIdType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FromViewIdType.java
deleted file mode 100644
index 30dadc1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/FromViewIdType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>From View Id Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FromViewIdType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.FromViewIdType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFromViewIdType()
- * @model extendedMetaData="name='from-view-id_._type' kind='simple'"
- * @generated
- */
-public interface FromViewIdType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFromViewIdType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.FromViewIdType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getFromViewIdType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.FromViewIdType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // FromViewIdType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/IconType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/IconType.java
deleted file mode 100644
index aca11c3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/IconType.java
+++ /dev/null
@@ -1,151 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Icon Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.IconType#getSmallIcon <em>Small Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.IconType#getLargeIcon <em>Large Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.IconType#getLang <em>Lang</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.IconType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getIconType()
- * @model extendedMetaData="name='icon_._type' kind='empty'"
- * @generated
- */
-public interface IconType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Small Icon</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Small Icon</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Small Icon</em>' containment reference.
-	 * @see #setSmallIcon(SmallIconType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getIconType_SmallIcon()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='small-icon' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	SmallIconType getSmallIcon();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.IconType#getSmallIcon <em>Small Icon</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Small Icon</em>' containment reference.
-	 * @see #getSmallIcon()
-	 * @generated
-	 */
-	void setSmallIcon(SmallIconType value);
-
-    /**
-	 * Returns the value of the '<em><b>Large Icon</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Large Icon</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Large Icon</em>' containment reference.
-	 * @see #setLargeIcon(LargeIconType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getIconType_LargeIcon()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='large-icon' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	LargeIconType getLargeIcon();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.IconType#getLargeIcon <em>Large Icon</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Large Icon</em>' containment reference.
-	 * @see #getLargeIcon()
-	 * @generated
-	 */
-	void setLargeIcon(LargeIconType value);
-
-    /**
-	 * Returns the value of the '<em><b>Lang</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Lang</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Lang</em>' attribute.
-	 * @see #setLang(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getIconType_Lang()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.Language"
-	 *        extendedMetaData="kind='attribute' name='lang' namespace='http://www.w3.org/XML/1998/namespace'"
-	 * @generated
-	 */
-	String getLang();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.IconType#getLang <em>Lang</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Lang</em>' attribute.
-	 * @see #getLang()
-	 * @generated
-	 */
-	void setLang(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getIconType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.IconType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // IconType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/IfType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/IfType.java
deleted file mode 100644
index a7025d2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/IfType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>If Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.IfType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.IfType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getIfType()
- * @model extendedMetaData="name='if_._type' kind='simple'"
- * @generated
- */
-public interface IfType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getIfType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.IfType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getIfType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.IfType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // IfType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/KeyClassType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/KeyClassType.java
deleted file mode 100644
index 353f56d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/KeyClassType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Key Class Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.KeyClassType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.KeyClassType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getKeyClassType()
- * @model extendedMetaData="name='key-class_._type' kind='simple'"
- * @generated
- */
-public interface KeyClassType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getKeyClassType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.KeyClassType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getKeyClassType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.KeyClassType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // KeyClassType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/KeyType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/KeyType.java
deleted file mode 100644
index c5793b6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/KeyType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Key Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.KeyType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.KeyType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getKeyType()
- * @model extendedMetaData="name='key_._type' kind='simple'"
- * @generated
- */
-public interface KeyType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getKeyType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.KeyType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getKeyType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.KeyType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // KeyType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/LargeIconType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/LargeIconType.java
deleted file mode 100644
index 5d3c8ec..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/LargeIconType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Large Icon Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.LargeIconType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.LargeIconType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getLargeIconType()
- * @model extendedMetaData="name='large-icon_._type' kind='simple'"
- * @generated
- */
-public interface LargeIconType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getLargeIconType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.LargeIconType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getLargeIconType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.LargeIconType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // LargeIconType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/LifecycleExtensionType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/LifecycleExtensionType.java
deleted file mode 100644
index 94f9ca9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/LifecycleExtensionType.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Lifecycle Extension Type</b></em>'.
- * <!-- end-user-doc -->
- *
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getLifecycleExtensionType()
- * @model extendedMetaData="name='lifecycle-extension_._type'"
- * @generated
- */
-public interface LifecycleExtensionType extends ExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-} // LifecycleExtensionType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/LifecycleFactoryType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/LifecycleFactoryType.java
deleted file mode 100644
index 4f64a99..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/LifecycleFactoryType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Lifecycle Factory Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleFactoryType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleFactoryType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getLifecycleFactoryType()
- * @model extendedMetaData="name='lifecycle-factory_._type' kind='simple'"
- * @generated
- */
-public interface LifecycleFactoryType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getLifecycleFactoryType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleFactoryType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getLifecycleFactoryType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleFactoryType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // LifecycleFactoryType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/LifecycleType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/LifecycleType.java
deleted file mode 100644
index 6273ca4..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/LifecycleType.java
+++ /dev/null
@@ -1,104 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Lifecycle Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleType#getPhaseListener <em>Phase Listener</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleType#getLifecycleExtension <em>Lifecycle Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getLifecycleType()
- * @model extendedMetaData="name='lifecycle_._type' kind='elementOnly'"
- * @generated
- */
-public interface LifecycleType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Phase Listener</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.PhaseListenerType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Phase Listener</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>Phase Listener</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getLifecycleType_PhaseListener()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.PhaseListenerType" containment="true"
-	 *        extendedMetaData="kind='element' name='phase-listener' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getPhaseListener();
-
-    /**
-	 * Returns the value of the '<em><b>Lifecycle Extension</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleExtensionType}.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Lifecycle Extension</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>Lifecycle Extension</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getLifecycleType_LifecycleExtension()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.LifecycleExtensionType" containment="true"
-	 *        extendedMetaData="kind='element' name='lifecycle-extension' namespace='##targetNamespace'"
-	 * @generated
-	 */
-    EList getLifecycleExtension();
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getLifecycleType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // LifecycleType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ListEntriesType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ListEntriesType.java
deleted file mode 100644
index 43109f4..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ListEntriesType.java
+++ /dev/null
@@ -1,132 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>List Entries Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType#getValueClass <em>Value Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType#getNullValue <em>Null Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType#getValue <em>Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getListEntriesType()
- * @model extendedMetaData="name='list-entries_._type' kind='elementOnly'"
- * @generated
- */
-public interface ListEntriesType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Value Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Value Class</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Value Class</em>' containment reference.
-	 * @see #setValueClass(ValueClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getListEntriesType_ValueClass()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='value-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ValueClassType getValueClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType#getValueClass <em>Value Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Value Class</em>' containment reference.
-	 * @see #getValueClass()
-	 * @generated
-	 */
-	void setValueClass(ValueClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Null Value</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.NullValueType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Null Value</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>Null Value</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getListEntriesType_NullValue()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.NullValueType" containment="true"
-	 *        extendedMetaData="kind='element' name='null-value' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getNullValue();
-
-    /**
-	 * Returns the value of the '<em><b>Value</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ValueType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Value</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>Value</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getListEntriesType_Value()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ValueType" containment="true"
-	 *        extendedMetaData="kind='element' name='value' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getValue();
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getListEntriesType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ListEntriesType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/LocaleConfigType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/LocaleConfigType.java
deleted file mode 100644
index a92adf2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/LocaleConfigType.java
+++ /dev/null
@@ -1,114 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Locale Config Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType#getDefaultLocale <em>Default Locale</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType#getSupportedLocale <em>Supported Locale</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getLocaleConfigType()
- * @model extendedMetaData="name='locale-config_._type' kind='elementOnly'"
- * @generated
- */
-public interface LocaleConfigType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Default Locale</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Default Locale</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Default Locale</em>' containment reference.
-	 * @see #setDefaultLocale(DefaultLocaleType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getLocaleConfigType_DefaultLocale()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='default-locale' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	DefaultLocaleType getDefaultLocale();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType#getDefaultLocale <em>Default Locale</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Default Locale</em>' containment reference.
-	 * @see #getDefaultLocale()
-	 * @generated
-	 */
-	void setDefaultLocale(DefaultLocaleType value);
-
-    /**
-	 * Returns the value of the '<em><b>Supported Locale</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.SupportedLocaleType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Supported Locale</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>Supported Locale</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getLocaleConfigType_SupportedLocale()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.SupportedLocaleType" containment="true"
-	 *        extendedMetaData="kind='element' name='supported-locale' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getSupportedLocale();
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getLocaleConfigType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // LocaleConfigType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ManagedBeanClassType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ManagedBeanClassType.java
deleted file mode 100644
index 0860211..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ManagedBeanClassType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Managed Bean Class Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanClassType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanClassType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanClassType()
- * @model extendedMetaData="name='managed-bean-class_._type' kind='simple'"
- * @generated
- */
-public interface ManagedBeanClassType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanClassType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanClassType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanClassType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanClassType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ManagedBeanClassType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ManagedBeanExtensionType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ManagedBeanExtensionType.java
deleted file mode 100644
index 597491e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ManagedBeanExtensionType.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Managed Bean Extension Type</b></em>'.
- * <!-- end-user-doc -->
- *
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanExtensionType()
- * @model extendedMetaData="name='managed-bean-extension_._type'"
- * @generated
- */
-public interface ManagedBeanExtensionType extends ExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-} // ManagedBeanExtensionType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ManagedBeanNameType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ManagedBeanNameType.java
deleted file mode 100644
index 8ff695b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ManagedBeanNameType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Managed Bean Name Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanNameType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanNameType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanNameType()
- * @model extendedMetaData="name='managed-bean-name_._type' kind='simple'"
- * @generated
- */
-public interface ManagedBeanNameType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanNameType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanNameType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanNameType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanNameType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ManagedBeanNameType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ManagedBeanScopeType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ManagedBeanScopeType.java
deleted file mode 100644
index 3c71f87..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ManagedBeanScopeType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Managed Bean Scope Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanScopeType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanScopeType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanScopeType()
- * @model extendedMetaData="name='managed-bean-scope_._type' kind='simple'"
- * @generated
- */
-public interface ManagedBeanScopeType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanScopeType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanScopeType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanScopeType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanScopeType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ManagedBeanScopeType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ManagedBeanType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ManagedBeanType.java
deleted file mode 100644
index f1e392a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ManagedBeanType.java
+++ /dev/null
@@ -1,326 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Managed Bean Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getManagedBeanName <em>Managed Bean Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getManagedBeanClass <em>Managed Bean Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getManagedBeanScope <em>Managed Bean Scope</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getManagedProperty <em>Managed Property</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getMapEntries <em>Map Entries</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getListEntries <em>List Entries</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getManagedBeanExtension <em>Managed Bean Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getId <em>Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#isEager <em>Eager</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanType()
- * @model extendedMetaData="name='managed-bean_._type' kind='elementOnly'"
- * @generated
- */
-public interface ManagedBeanType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Description</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Description</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>Description</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanType_Description()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DescriptionType" containment="true"
-	 *        extendedMetaData="kind='element' name='description' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDescription();
-
-    /**
-	 * Returns the value of the '<em><b>Display Name</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Display Name</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>Display Name</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanType_DisplayName()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType" containment="true"
-	 *        extendedMetaData="kind='element' name='display-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDisplayName();
-
-    /**
-	 * Returns the value of the '<em><b>Icon</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.IconType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Icon</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>Icon</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanType_Icon()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.IconType" containment="true"
-	 *        extendedMetaData="kind='element' name='icon' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getIcon();
-
-    /**
-	 * Returns the value of the '<em><b>Managed Bean Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Managed Bean Name</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Managed Bean Name</em>' containment reference.
-	 * @see #setManagedBeanName(ManagedBeanNameType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanType_ManagedBeanName()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='managed-bean-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ManagedBeanNameType getManagedBeanName();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getManagedBeanName <em>Managed Bean Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Managed Bean Name</em>' containment reference.
-	 * @see #getManagedBeanName()
-	 * @generated
-	 */
-	void setManagedBeanName(ManagedBeanNameType value);
-
-    /**
-	 * Returns the value of the '<em><b>Managed Bean Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Managed Bean Class</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Managed Bean Class</em>' containment reference.
-	 * @see #setManagedBeanClass(ManagedBeanClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanType_ManagedBeanClass()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='managed-bean-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ManagedBeanClassType getManagedBeanClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getManagedBeanClass <em>Managed Bean Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Managed Bean Class</em>' containment reference.
-	 * @see #getManagedBeanClass()
-	 * @generated
-	 */
-	void setManagedBeanClass(ManagedBeanClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Managed Bean Scope</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Managed Bean Scope</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Managed Bean Scope</em>' containment reference.
-	 * @see #setManagedBeanScope(ManagedBeanScopeType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanType_ManagedBeanScope()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='managed-bean-scope' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ManagedBeanScopeType getManagedBeanScope();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getManagedBeanScope <em>Managed Bean Scope</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Managed Bean Scope</em>' containment reference.
-	 * @see #getManagedBeanScope()
-	 * @generated
-	 */
-	void setManagedBeanScope(ManagedBeanScopeType value);
-
-    /**
-	 * Returns the value of the '<em><b>Managed Property</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Managed Property</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>Managed Property</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanType_ManagedProperty()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType" containment="true"
-	 *        extendedMetaData="kind='element' name='managed-property' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getManagedProperty();
-
-    /**
-	 * Returns the value of the '<em><b>Map Entries</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Map Entries</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Map Entries</em>' containment reference.
-	 * @see #setMapEntries(MapEntriesType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanType_MapEntries()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='map-entries' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	MapEntriesType getMapEntries();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getMapEntries <em>Map Entries</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Map Entries</em>' containment reference.
-	 * @see #getMapEntries()
-	 * @generated
-	 */
-	void setMapEntries(MapEntriesType value);
-
-    /**
-	 * Returns the value of the '<em><b>List Entries</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>List Entries</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>List Entries</em>' containment reference.
-	 * @see #setListEntries(ListEntriesType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanType_ListEntries()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='list-entries' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ListEntriesType getListEntries();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getListEntries <em>List Entries</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>List Entries</em>' containment reference.
-	 * @see #getListEntries()
-	 * @generated
-	 */
-	void setListEntries(ListEntriesType value);
-
-    /**
-	 * Returns the value of the '<em><b>Managed Bean Extension</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanExtensionType}.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Managed Bean Extension</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>Managed Bean Extension</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanType_ManagedBeanExtension()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanExtensionType" containment="true"
-	 *        extendedMetaData="kind='element' name='managed-bean-extension' namespace='##targetNamespace'"
-	 * @generated
-	 */
-    EList getManagedBeanExtension();
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-				/**
-	 * Returns the value of the '<em><b>Eager</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Eager</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Eager</em>' attribute.
-	 * @see #setEager(boolean)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedBeanType_Eager()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.Boolean"
-	 *        extendedMetaData="kind='attribute' name='eager' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	boolean isEager();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType#isEager <em>Eager</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Eager</em>' attribute.
-	 * @see #isEager()
-	 * @generated
-	 */
-	void setEager(boolean value);
-
-} // ManagedBeanType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ManagedPropertyType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ManagedPropertyType.java
deleted file mode 100644
index 4a06a39..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ManagedPropertyType.java
+++ /dev/null
@@ -1,290 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Managed Property Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getPropertyName <em>Property Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getPropertyClass <em>Property Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getMapEntries <em>Map Entries</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getNullValue <em>Null Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getValue <em>Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getListEntries <em>List Entries</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedPropertyType()
- * @model extendedMetaData="name='managed-property_._type' kind='elementOnly'"
- * @generated
- */
-public interface ManagedPropertyType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Description</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Description</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>Description</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedPropertyType_Description()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DescriptionType" containment="true"
-	 *        extendedMetaData="kind='element' name='description' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDescription();
-
-    /**
-	 * Returns the value of the '<em><b>Display Name</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Display Name</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>Display Name</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedPropertyType_DisplayName()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType" containment="true"
-	 *        extendedMetaData="kind='element' name='display-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDisplayName();
-
-    /**
-	 * Returns the value of the '<em><b>Icon</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.IconType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Icon</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>Icon</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedPropertyType_Icon()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.IconType" containment="true"
-	 *        extendedMetaData="kind='element' name='icon' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getIcon();
-
-    /**
-	 * Returns the value of the '<em><b>Property Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Property Name</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Property Name</em>' containment reference.
-	 * @see #setPropertyName(PropertyNameType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedPropertyType_PropertyName()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='property-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	PropertyNameType getPropertyName();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getPropertyName <em>Property Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Property Name</em>' containment reference.
-	 * @see #getPropertyName()
-	 * @generated
-	 */
-	void setPropertyName(PropertyNameType value);
-
-    /**
-	 * Returns the value of the '<em><b>Property Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Property Class</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Property Class</em>' containment reference.
-	 * @see #setPropertyClass(PropertyClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedPropertyType_PropertyClass()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='property-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	PropertyClassType getPropertyClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getPropertyClass <em>Property Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Property Class</em>' containment reference.
-	 * @see #getPropertyClass()
-	 * @generated
-	 */
-	void setPropertyClass(PropertyClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Map Entries</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Map Entries</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Map Entries</em>' containment reference.
-	 * @see #setMapEntries(MapEntriesType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedPropertyType_MapEntries()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='map-entries' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	MapEntriesType getMapEntries();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getMapEntries <em>Map Entries</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Map Entries</em>' containment reference.
-	 * @see #getMapEntries()
-	 * @generated
-	 */
-	void setMapEntries(MapEntriesType value);
-
-    /**
-	 * Returns the value of the '<em><b>Null Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Null Value</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Null Value</em>' containment reference.
-	 * @see #setNullValue(NullValueType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedPropertyType_NullValue()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='null-value' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	NullValueType getNullValue();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getNullValue <em>Null Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Null Value</em>' containment reference.
-	 * @see #getNullValue()
-	 * @generated
-	 */
-	void setNullValue(NullValueType value);
-
-    /**
-	 * Returns the value of the '<em><b>Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Value</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Value</em>' containment reference.
-	 * @see #setValue(ValueType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedPropertyType_Value()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='value' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ValueType getValue();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getValue <em>Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Value</em>' containment reference.
-	 * @see #getValue()
-	 * @generated
-	 */
-	void setValue(ValueType value);
-
-    /**
-	 * Returns the value of the '<em><b>List Entries</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>List Entries</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>List Entries</em>' containment reference.
-	 * @see #setListEntries(ListEntriesType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedPropertyType_ListEntries()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='list-entries' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ListEntriesType getListEntries();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getListEntries <em>List Entries</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>List Entries</em>' containment reference.
-	 * @see #getListEntries()
-	 * @generated
-	 */
-	void setListEntries(ListEntriesType value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getManagedPropertyType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ManagedPropertyType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/MapEntriesType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/MapEntriesType.java
deleted file mode 100644
index f09502f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/MapEntriesType.java
+++ /dev/null
@@ -1,142 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Map Entries Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType#getKeyClass <em>Key Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType#getValueClass <em>Value Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType#getMapEntry <em>Map Entry</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getMapEntriesType()
- * @model extendedMetaData="name='map-entries_._type' kind='elementOnly'"
- * @generated
- */
-public interface MapEntriesType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Key Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Key Class</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Key Class</em>' containment reference.
-	 * @see #setKeyClass(KeyClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getMapEntriesType_KeyClass()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='key-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	KeyClassType getKeyClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType#getKeyClass <em>Key Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Key Class</em>' containment reference.
-	 * @see #getKeyClass()
-	 * @generated
-	 */
-	void setKeyClass(KeyClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Value Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Value Class</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Value Class</em>' containment reference.
-	 * @see #setValueClass(ValueClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getMapEntriesType_ValueClass()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='value-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ValueClassType getValueClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType#getValueClass <em>Value Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Value Class</em>' containment reference.
-	 * @see #getValueClass()
-	 * @generated
-	 */
-	void setValueClass(ValueClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Map Entry</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.MapEntryType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Map Entry</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>Map Entry</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getMapEntriesType_MapEntry()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.MapEntryType" containment="true"
-	 *        extendedMetaData="kind='element' name='map-entry' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getMapEntry();
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getMapEntriesType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // MapEntriesType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/MapEntryType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/MapEntryType.java
deleted file mode 100644
index 11e832e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/MapEntryType.java
+++ /dev/null
@@ -1,151 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Map Entry Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntryType#getKey <em>Key</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntryType#getNullValue <em>Null Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntryType#getValue <em>Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntryType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getMapEntryType()
- * @model extendedMetaData="name='map-entry_._type' kind='empty'"
- * @generated
- */
-public interface MapEntryType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Key</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Key</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Key</em>' containment reference.
-	 * @see #setKey(KeyType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getMapEntryType_Key()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='key' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	KeyType getKey();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntryType#getKey <em>Key</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Key</em>' containment reference.
-	 * @see #getKey()
-	 * @generated
-	 */
-	void setKey(KeyType value);
-
-    /**
-	 * Returns the value of the '<em><b>Null Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Null Value</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Null Value</em>' containment reference.
-	 * @see #setNullValue(NullValueType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getMapEntryType_NullValue()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='null-value' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	NullValueType getNullValue();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntryType#getNullValue <em>Null Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Null Value</em>' containment reference.
-	 * @see #getNullValue()
-	 * @generated
-	 */
-	void setNullValue(NullValueType value);
-
-    /**
-	 * Returns the value of the '<em><b>Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Value</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Value</em>' containment reference.
-	 * @see #setValue(ValueType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getMapEntryType_Value()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='value' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ValueType getValue();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntryType#getValue <em>Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Value</em>' containment reference.
-	 * @see #getValue()
-	 * @generated
-	 */
-	void setValue(ValueType value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getMapEntryType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntryType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // MapEntryType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/MessageBundleType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/MessageBundleType.java
deleted file mode 100644
index 0dbf441..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/MessageBundleType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Message Bundle Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.MessageBundleType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.MessageBundleType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getMessageBundleType()
- * @model extendedMetaData="name='message-bundle_._type' kind='simple'"
- * @generated
- */
-public interface MessageBundleType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getMessageBundleType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.MessageBundleType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getMessageBundleType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.MessageBundleType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // MessageBundleType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/NameType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/NameType.java
deleted file mode 100644
index 2d93c6e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/NameType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Name Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.NameType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.NameType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNameType()
- * @model extendedMetaData="name='name_._type' kind='simple'"
- * @generated
- */
-public interface NameType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNameType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.NameType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNameType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.NameType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // NameType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/NavigationCaseType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/NavigationCaseType.java
deleted file mode 100644
index a208e38..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/NavigationCaseType.java
+++ /dev/null
@@ -1,262 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Navigation Case Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getFromAction <em>From Action</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getFromOutcome <em>From Outcome</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getIf <em>If</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getToViewId <em>To View Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getRedirect <em>Redirect</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationCaseType()
- * @model extendedMetaData="name='navigation-case_._type' kind='elementOnly'"
- * @generated
- */
-public interface NavigationCaseType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Description</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Description</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>Description</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationCaseType_Description()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DescriptionType" containment="true"
-	 *        extendedMetaData="kind='element' name='description' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDescription();
-
-    /**
-	 * Returns the value of the '<em><b>Display Name</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Display Name</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>Display Name</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationCaseType_DisplayName()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType" containment="true"
-	 *        extendedMetaData="kind='element' name='display-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDisplayName();
-
-    /**
-	 * Returns the value of the '<em><b>Icon</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.IconType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Icon</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>Icon</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationCaseType_Icon()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.IconType" containment="true"
-	 *        extendedMetaData="kind='element' name='icon' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getIcon();
-
-    /**
-	 * Returns the value of the '<em><b>From Action</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>From Action</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>From Action</em>' containment reference.
-	 * @see #setFromAction(FromActionType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationCaseType_FromAction()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='from-action' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	FromActionType getFromAction();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getFromAction <em>From Action</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>From Action</em>' containment reference.
-	 * @see #getFromAction()
-	 * @generated
-	 */
-	void setFromAction(FromActionType value);
-
-    /**
-	 * Returns the value of the '<em><b>From Outcome</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>From Outcome</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>From Outcome</em>' containment reference.
-	 * @see #setFromOutcome(FromOutcomeType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationCaseType_FromOutcome()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='from-outcome' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	FromOutcomeType getFromOutcome();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getFromOutcome <em>From Outcome</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>From Outcome</em>' containment reference.
-	 * @see #getFromOutcome()
-	 * @generated
-	 */
-	void setFromOutcome(FromOutcomeType value);
-
-    /**
-	 * Returns the value of the '<em><b>If</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>If</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>If</em>' containment reference.
-	 * @see #setIf(IfType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationCaseType_If()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='if' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	IfType getIf();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getIf <em>If</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>If</em>' containment reference.
-	 * @see #getIf()
-	 * @generated
-	 */
-	void setIf(IfType value);
-
-				/**
-	 * Returns the value of the '<em><b>To View Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>To View Id</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>To View Id</em>' containment reference.
-	 * @see #setToViewId(ToViewIdType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationCaseType_ToViewId()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='to-view-id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ToViewIdType getToViewId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getToViewId <em>To View Id</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>To View Id</em>' containment reference.
-	 * @see #getToViewId()
-	 * @generated
-	 */
-	void setToViewId(ToViewIdType value);
-
-    /**
-	 * Returns the value of the '<em><b>Redirect</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Redirect</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Redirect</em>' containment reference.
-	 * @see #setRedirect(RedirectType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationCaseType_Redirect()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='redirect' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	RedirectType getRedirect();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getRedirect <em>Redirect</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Redirect</em>' containment reference.
-	 * @see #getRedirect()
-	 * @generated
-	 */
-	void setRedirect(RedirectType value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationCaseType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // NavigationCaseType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/NavigationHandlerType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/NavigationHandlerType.java
deleted file mode 100644
index 0744840..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/NavigationHandlerType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Navigation Handler Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationHandlerType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationHandlerType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationHandlerType()
- * @model extendedMetaData="name='navigation-handler_._type' kind='simple'"
- * @generated
- */
-public interface NavigationHandlerType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationHandlerType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationHandlerType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationHandlerType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationHandlerType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // NavigationHandlerType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/NavigationRuleExtensionType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/NavigationRuleExtensionType.java
deleted file mode 100644
index 7a0fdec..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/NavigationRuleExtensionType.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Navigation Rule Extension Type</b></em>'.
- * <!-- end-user-doc -->
- *
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationRuleExtensionType()
- * @model extendedMetaData="name='navigation-rule-extension_._type'"
- * @generated
- */
-public interface NavigationRuleExtensionType extends ExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-} // NavigationRuleExtensionType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/NavigationRuleType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/NavigationRuleType.java
deleted file mode 100644
index c36b87d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/NavigationRuleType.java
+++ /dev/null
@@ -1,186 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Navigation Rule Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getFromViewId <em>From View Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getNavigationCase <em>Navigation Case</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getNavigationRuleExtension <em>Navigation Rule Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationRuleType()
- * @model extendedMetaData="name='navigation-rule_._type' kind='elementOnly'"
- * @generated
- */
-public interface NavigationRuleType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Description</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Description</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>Description</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationRuleType_Description()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DescriptionType" containment="true"
-	 *        extendedMetaData="kind='element' name='description' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDescription();
-
-    /**
-	 * Returns the value of the '<em><b>Display Name</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Display Name</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>Display Name</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationRuleType_DisplayName()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType" containment="true"
-	 *        extendedMetaData="kind='element' name='display-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDisplayName();
-
-    /**
-	 * Returns the value of the '<em><b>Icon</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.IconType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Icon</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>Icon</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationRuleType_Icon()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.IconType" containment="true"
-	 *        extendedMetaData="kind='element' name='icon' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getIcon();
-
-    /**
-	 * Returns the value of the '<em><b>From View Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>From View Id</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>From View Id</em>' containment reference.
-	 * @see #setFromViewId(FromViewIdType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationRuleType_FromViewId()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='from-view-id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	FromViewIdType getFromViewId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getFromViewId <em>From View Id</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>From View Id</em>' containment reference.
-	 * @see #getFromViewId()
-	 * @generated
-	 */
-	void setFromViewId(FromViewIdType value);
-
-    /**
-	 * Returns the value of the '<em><b>Navigation Case</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Navigation Case</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>Navigation Case</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationRuleType_NavigationCase()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType" containment="true"
-	 *        extendedMetaData="kind='element' name='navigation-case' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getNavigationCase();
-
-    /**
-	 * Returns the value of the '<em><b>Navigation Rule Extension</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleExtensionType}.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Navigation Rule Extension</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>Navigation Rule Extension</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationRuleType_NavigationRuleExtension()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleExtensionType" containment="true"
-	 *        extendedMetaData="kind='element' name='navigation-rule-extension' namespace='##targetNamespace'"
-	 * @generated
-	 */
-    EList getNavigationRuleExtension();
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNavigationRuleType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // NavigationRuleType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/NullValueType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/NullValueType.java
deleted file mode 100644
index 390fb1a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/NullValueType.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Null Value Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.NullValueType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNullValueType()
- * @model extendedMetaData="name='null-value_._type' kind='empty'"
- * @generated
- */
-public interface NullValueType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getNullValueType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.NullValueType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // NullValueType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/OrderingOrderingType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/OrderingOrderingType.java
deleted file mode 100644
index 5eeabde..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/OrderingOrderingType.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Ordering Ordering Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.OrderingOrderingType#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.OrderingOrderingType#getOthers <em>Others</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getOrderingOrderingType()
- * @model extendedMetaData="name='ordering-ordering_._type' kind='elementOnly'"
- * @generated
- */
-public interface OrderingOrderingType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Name</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.NameType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Name</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>Name</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getOrderingOrderingType_Name()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.NameType" containment="true"
-	 *        extendedMetaData="kind='element' name='name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getName();
-
-	/**
-	 * Returns the value of the '<em><b>Others</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Others</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Others</em>' containment reference.
-	 * @see #setOthers(OrderingOthersType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getOrderingOrderingType_Others()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='others' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	OrderingOthersType getOthers();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.OrderingOrderingType#getOthers <em>Others</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Others</em>' containment reference.
-	 * @see #getOthers()
-	 * @generated
-	 */
-	void setOthers(OrderingOthersType value);
-
-} // OrderingOrderingType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/OrderingOthersType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/OrderingOthersType.java
deleted file mode 100644
index 9251006..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/OrderingOthersType.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Ordering Others Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.OrderingOthersType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getOrderingOthersType()
- * @model extendedMetaData="name='others_._type' kind='elementOnly'"
- * @generated
- */
-public interface OrderingOthersType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getOrderingOthersType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.OrderingOthersType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // OrderingOthersType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/OrderingType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/OrderingType.java
deleted file mode 100644
index b145ddd..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/OrderingType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Ordering Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.OrderingType#getBefore <em>Before</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.OrderingType#getAfter <em>After</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getOrderingType()
- * @model extendedMetaData="name='ordering_._type' kind='elementOnly'"
- * @generated
- */
-public interface OrderingType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Before</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Before</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Before</em>' containment reference.
-	 * @see #setBefore(OrderingOrderingType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getOrderingType_Before()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='before' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	OrderingOrderingType getBefore();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.OrderingType#getBefore <em>Before</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Before</em>' containment reference.
-	 * @see #getBefore()
-	 * @generated
-	 */
-	void setBefore(OrderingOrderingType value);
-
-	/**
-	 * Returns the value of the '<em><b>After</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>After</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>After</em>' containment reference.
-	 * @see #setAfter(OrderingOrderingType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getOrderingType_After()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='after' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	OrderingOrderingType getAfter();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.OrderingType#getAfter <em>After</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>After</em>' containment reference.
-	 * @see #getAfter()
-	 * @generated
-	 */
-	void setAfter(OrderingOrderingType value);
-
-} // OrderingType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/PartialViewContextFactoryType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/PartialViewContextFactoryType.java
deleted file mode 100644
index e10d1d5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/PartialViewContextFactoryType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Partial View Context Factory Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.PartialViewContextFactoryType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.PartialViewContextFactoryType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPartialViewContextFactoryType()
- * @model extendedMetaData="name='partial-view-context-factory_._type' kind='simple'"
- * @generated
- */
-public interface PartialViewContextFactoryType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPartialViewContextFactoryType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.PartialViewContextFactoryType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPartialViewContextFactoryType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.PartialViewContextFactoryType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // PartialViewContextFactoryType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/PhaseListenerType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/PhaseListenerType.java
deleted file mode 100644
index b175658..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/PhaseListenerType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Phase Listener Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.PhaseListenerType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.PhaseListenerType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPhaseListenerType()
- * @model extendedMetaData="name='phase-listener_._type' kind='simple'"
- * @generated
- */
-public interface PhaseListenerType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPhaseListenerType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.PhaseListenerType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPhaseListenerType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.PhaseListenerType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // PhaseListenerType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/PropertyClassType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/PropertyClassType.java
deleted file mode 100644
index 42ddc6b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/PropertyClassType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Property Class Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyClassType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyClassType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPropertyClassType()
- * @model extendedMetaData="name='property-class_._type' kind='simple'"
- * @generated
- */
-public interface PropertyClassType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPropertyClassType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyClassType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPropertyClassType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyClassType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // PropertyClassType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/PropertyExtensionType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/PropertyExtensionType.java
deleted file mode 100644
index c31c1e5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/PropertyExtensionType.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Property Extension Type</b></em>'.
- * <!-- end-user-doc -->
- *
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPropertyExtensionType()
- * @model extendedMetaData="name='property-extension_._type'"
- * @generated
- */
-public interface PropertyExtensionType extends ExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-} // PropertyExtensionType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/PropertyNameType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/PropertyNameType.java
deleted file mode 100644
index 45432b6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/PropertyNameType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Property Name Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyNameType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyNameType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPropertyNameType()
- * @model extendedMetaData="name='property-name_._type' kind='simple'"
- * @generated
- */
-public interface PropertyNameType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPropertyNameType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyNameType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPropertyNameType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyNameType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // PropertyNameType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/PropertyResolverType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/PropertyResolverType.java
deleted file mode 100644
index 6ec2e5e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/PropertyResolverType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Property Resolver Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyResolverType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyResolverType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPropertyResolverType()
- * @model extendedMetaData="name='property-resolver_._type' kind='simple'"
- * @generated
- */
-public interface PropertyResolverType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPropertyResolverType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyResolverType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPropertyResolverType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyResolverType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // PropertyResolverType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/PropertyType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/PropertyType.java
deleted file mode 100644
index fcee95f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/PropertyType.java
+++ /dev/null
@@ -1,252 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Property Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getPropertyName <em>Property Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getPropertyClass <em>Property Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getDefaultValue <em>Default Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getSuggestedValue <em>Suggested Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getPropertyExtension <em>Property Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPropertyType()
- * @model extendedMetaData="name='property_._type' kind='elementOnly'"
- * @generated
- */
-public interface PropertyType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Description</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Description</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>Description</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPropertyType_Description()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DescriptionType" containment="true"
-	 *        extendedMetaData="kind='element' name='description' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDescription();
-
-    /**
-	 * Returns the value of the '<em><b>Display Name</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Display Name</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>Display Name</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPropertyType_DisplayName()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType" containment="true"
-	 *        extendedMetaData="kind='element' name='display-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDisplayName();
-
-    /**
-	 * Returns the value of the '<em><b>Icon</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.IconType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Icon</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>Icon</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPropertyType_Icon()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.IconType" containment="true"
-	 *        extendedMetaData="kind='element' name='icon' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getIcon();
-
-    /**
-	 * Returns the value of the '<em><b>Property Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Property Name</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Property Name</em>' containment reference.
-	 * @see #setPropertyName(PropertyNameType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPropertyType_PropertyName()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='property-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	PropertyNameType getPropertyName();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getPropertyName <em>Property Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Property Name</em>' containment reference.
-	 * @see #getPropertyName()
-	 * @generated
-	 */
-	void setPropertyName(PropertyNameType value);
-
-    /**
-	 * Returns the value of the '<em><b>Property Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Property Class</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Property Class</em>' containment reference.
-	 * @see #setPropertyClass(PropertyClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPropertyType_PropertyClass()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='property-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	PropertyClassType getPropertyClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getPropertyClass <em>Property Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Property Class</em>' containment reference.
-	 * @see #getPropertyClass()
-	 * @generated
-	 */
-	void setPropertyClass(PropertyClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Default Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Default Value</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Default Value</em>' containment reference.
-	 * @see #setDefaultValue(DefaultValueType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPropertyType_DefaultValue()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='default-value' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	DefaultValueType getDefaultValue();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getDefaultValue <em>Default Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Default Value</em>' containment reference.
-	 * @see #getDefaultValue()
-	 * @generated
-	 */
-	void setDefaultValue(DefaultValueType value);
-
-    /**
-	 * Returns the value of the '<em><b>Suggested Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Suggested Value</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Suggested Value</em>' containment reference.
-	 * @see #setSuggestedValue(SuggestedValueType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPropertyType_SuggestedValue()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='suggested-value' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	SuggestedValueType getSuggestedValue();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getSuggestedValue <em>Suggested Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Suggested Value</em>' containment reference.
-	 * @see #getSuggestedValue()
-	 * @generated
-	 */
-	void setSuggestedValue(SuggestedValueType value);
-
-    /**
-	 * Returns the value of the '<em><b>Property Extension</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.PropertyExtensionType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Property Extension</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>Property Extension</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPropertyType_PropertyExtension()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.PropertyExtensionType" containment="true"
-	 *        extendedMetaData="kind='element' name='property-extension' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getPropertyExtension();
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getPropertyType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // PropertyType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RedirectType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RedirectType.java
deleted file mode 100644
index dc7d1cc..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RedirectType.java
+++ /dev/null
@@ -1,114 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Redirect Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RedirectType#getViewParam <em>View Param</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RedirectType#getId <em>Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RedirectType#isIncludeViewParams <em>Include View Params</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRedirectType()
- * @model extendedMetaData="name='redirect_._type' kind='empty'"
- * @generated
- */
-public interface RedirectType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>View Param</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>View Param</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>View Param</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRedirectType_ViewParam()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType" containment="true"
-	 *        extendedMetaData="kind='element' name='view-param' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getViewParam();
-
-				/**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRedirectType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RedirectType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-				/**
-	 * Returns the value of the '<em><b>Include View Params</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Include View Params</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Include View Params</em>' attribute.
-	 * @see #setIncludeViewParams(boolean)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRedirectType_IncludeViewParams()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.Boolean"
-	 *        extendedMetaData="kind='attribute' name='include-view-params' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	boolean isIncludeViewParams();
-
-				/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RedirectType#isIncludeViewParams <em>Include View Params</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Include View Params</em>' attribute.
-	 * @see #isIncludeViewParams()
-	 * @generated
-	 */
-	void setIncludeViewParams(boolean value);
-
-} // RedirectType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RedirectViewParamType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RedirectViewParamType.java
deleted file mode 100644
index f7b5360..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RedirectViewParamType.java
+++ /dev/null
@@ -1,123 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Redirect View Param Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType#getValue <em>Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRedirectViewParamType()
- * @model extendedMetaData="name='redirect-viewParam_._type' kind='empty'"
- * @generated
- */
-public interface RedirectViewParamType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Name</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Name</em>' containment reference.
-	 * @see #setName(NameType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRedirectViewParamType_Name()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	NameType getName();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType#getName <em>Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Name</em>' containment reference.
-	 * @see #getName()
-	 * @generated
-	 */
-	void setName(NameType value);
-
-	/**
-	 * Returns the value of the '<em><b>Value</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Value</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Value</em>' containment reference.
-	 * @see #setValue(ValueType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRedirectViewParamType_Value()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='value' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ValueType getValue();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType#getValue <em>Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Value</em>' containment reference.
-	 * @see #getValue()
-	 * @generated
-	 */
-	void setValue(ValueType value);
-
-	/**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRedirectViewParamType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // RedirectViewParamType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ReferencedBeanClassType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ReferencedBeanClassType.java
deleted file mode 100644
index 91d9c42..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ReferencedBeanClassType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Referenced Bean Class Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanClassType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanClassType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getReferencedBeanClassType()
- * @model extendedMetaData="name='referenced-bean-class_._type' kind='simple'"
- * @generated
- */
-public interface ReferencedBeanClassType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getReferencedBeanClassType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanClassType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getReferencedBeanClassType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanClassType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ReferencedBeanClassType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ReferencedBeanNameType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ReferencedBeanNameType.java
deleted file mode 100644
index bb47210..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ReferencedBeanNameType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Referenced Bean Name Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanNameType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanNameType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getReferencedBeanNameType()
- * @model extendedMetaData="name='referenced-bean-name_._type' kind='simple'"
- * @generated
- */
-public interface ReferencedBeanNameType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getReferencedBeanNameType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanNameType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getReferencedBeanNameType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanNameType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ReferencedBeanNameType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ReferencedBeanType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ReferencedBeanType.java
deleted file mode 100644
index 00049aa..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ReferencedBeanType.java
+++ /dev/null
@@ -1,178 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Referenced Bean Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType#getReferencedBeanName <em>Referenced Bean Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType#getReferencedBeanClass <em>Referenced Bean Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getReferencedBeanType()
- * @model extendedMetaData="name='referenced-bean_._type' kind='elementOnly'"
- * @generated
- */
-public interface ReferencedBeanType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Description</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Description</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>Description</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getReferencedBeanType_Description()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DescriptionType" containment="true"
-	 *        extendedMetaData="kind='element' name='description' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDescription();
-
-    /**
-	 * Returns the value of the '<em><b>Display Name</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Display Name</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>Display Name</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getReferencedBeanType_DisplayName()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType" containment="true"
-	 *        extendedMetaData="kind='element' name='display-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDisplayName();
-
-    /**
-	 * Returns the value of the '<em><b>Icon</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.IconType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Icon</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>Icon</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getReferencedBeanType_Icon()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.IconType" containment="true"
-	 *        extendedMetaData="kind='element' name='icon' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getIcon();
-
-    /**
-	 * Returns the value of the '<em><b>Referenced Bean Name</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Referenced Bean Name</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Referenced Bean Name</em>' containment reference.
-	 * @see #setReferencedBeanName(ReferencedBeanNameType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getReferencedBeanType_ReferencedBeanName()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='referenced-bean-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ReferencedBeanNameType getReferencedBeanName();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType#getReferencedBeanName <em>Referenced Bean Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Referenced Bean Name</em>' containment reference.
-	 * @see #getReferencedBeanName()
-	 * @generated
-	 */
-	void setReferencedBeanName(ReferencedBeanNameType value);
-
-    /**
-	 * Returns the value of the '<em><b>Referenced Bean Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Referenced Bean Class</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Referenced Bean Class</em>' containment reference.
-	 * @see #setReferencedBeanClass(ReferencedBeanClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getReferencedBeanType_ReferencedBeanClass()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='referenced-bean-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ReferencedBeanClassType getReferencedBeanClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType#getReferencedBeanClass <em>Referenced Bean Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Referenced Bean Class</em>' containment reference.
-	 * @see #getReferencedBeanClass()
-	 * @generated
-	 */
-	void setReferencedBeanClass(ReferencedBeanClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getReferencedBeanType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ReferencedBeanType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RenderKitClassType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RenderKitClassType.java
deleted file mode 100644
index 863cb61..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RenderKitClassType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Render Kit Class Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitClassType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitClassType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRenderKitClassType()
- * @model extendedMetaData="name='render-kit-class_._type' kind='simple'"
- * @generated
- */
-public interface RenderKitClassType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRenderKitClassType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitClassType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRenderKitClassType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitClassType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // RenderKitClassType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RenderKitExtensionType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RenderKitExtensionType.java
deleted file mode 100644
index 0d4d365..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RenderKitExtensionType.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Render Kit Extension Type</b></em>'.
- * <!-- end-user-doc -->
- *
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRenderKitExtensionType()
- * @model extendedMetaData="name='render-kit-extension_._type'"
- * @generated
- */
-public interface RenderKitExtensionType extends ExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-} // RenderKitExtensionType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RenderKitFactoryType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RenderKitFactoryType.java
deleted file mode 100644
index c1e1284..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RenderKitFactoryType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Render Kit Factory Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitFactoryType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitFactoryType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRenderKitFactoryType()
- * @model extendedMetaData="name='render-kit-factory_._type' kind='simple'"
- * @generated
- */
-public interface RenderKitFactoryType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRenderKitFactoryType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitFactoryType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRenderKitFactoryType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitFactoryType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // RenderKitFactoryType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RenderKitIdType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RenderKitIdType.java
deleted file mode 100644
index e4c9b08..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RenderKitIdType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Render Kit Id Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitIdType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitIdType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRenderKitIdType()
- * @model extendedMetaData="name='render-kit-id_._type' kind='simple'"
- * @generated
- */
-public interface RenderKitIdType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRenderKitIdType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitIdType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRenderKitIdType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitIdType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // RenderKitIdType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RenderKitType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RenderKitType.java
deleted file mode 100644
index 05e3119..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RenderKitType.java
+++ /dev/null
@@ -1,232 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Render Kit Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getRenderKitId <em>Render Kit Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getRenderKitClass <em>Render Kit Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getRenderer <em>Renderer</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getClientBehaviorRenderer <em>Client Behavior Renderer</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getRenderKitExtension <em>Render Kit Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRenderKitType()
- * @model extendedMetaData="name='render-kit_._type' kind='elementOnly'"
- * @generated
- */
-public interface RenderKitType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Description</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Description</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>Description</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRenderKitType_Description()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DescriptionType" containment="true"
-	 *        extendedMetaData="kind='element' name='description' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDescription();
-
-    /**
-	 * Returns the value of the '<em><b>Display Name</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Display Name</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>Display Name</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRenderKitType_DisplayName()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType" containment="true"
-	 *        extendedMetaData="kind='element' name='display-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDisplayName();
-
-    /**
-	 * Returns the value of the '<em><b>Icon</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.IconType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Icon</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>Icon</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRenderKitType_Icon()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.IconType" containment="true"
-	 *        extendedMetaData="kind='element' name='icon' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getIcon();
-
-    /**
-	 * Returns the value of the '<em><b>Render Kit Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Render Kit Id</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Render Kit Id</em>' containment reference.
-	 * @see #setRenderKitId(RenderKitIdType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRenderKitType_RenderKitId()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='render-kit-id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	RenderKitIdType getRenderKitId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getRenderKitId <em>Render Kit Id</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Render Kit Id</em>' containment reference.
-	 * @see #getRenderKitId()
-	 * @generated
-	 */
-	void setRenderKitId(RenderKitIdType value);
-
-    /**
-	 * Returns the value of the '<em><b>Render Kit Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Render Kit Class</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Render Kit Class</em>' containment reference.
-	 * @see #setRenderKitClass(RenderKitClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRenderKitType_RenderKitClass()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='render-kit-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	RenderKitClassType getRenderKitClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getRenderKitClass <em>Render Kit Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Render Kit Class</em>' containment reference.
-	 * @see #getRenderKitClass()
-	 * @generated
-	 */
-	void setRenderKitClass(RenderKitClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Renderer</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.RendererType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Renderer</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>Renderer</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRenderKitType_Renderer()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.RendererType" containment="true"
-	 *        extendedMetaData="kind='element' name='renderer' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getRenderer();
-
-    /**
-	 * Returns the value of the '<em><b>Client Behavior Renderer</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Client Behavior Renderer</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>Client Behavior Renderer</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRenderKitType_ClientBehaviorRenderer()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererType" containment="true"
-	 *        extendedMetaData="kind='element' name='client-behavior-renderer' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getClientBehaviorRenderer();
-
-				/**
-	 * Returns the value of the '<em><b>Render Kit Extension</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitExtensionType}.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Render Kit Extension</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>Render Kit Extension</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRenderKitType_RenderKitExtension()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.RenderKitExtensionType" containment="true"
-	 *        extendedMetaData="kind='element' name='render-kit-extension' namespace='##targetNamespace'"
-	 * @generated
-	 */
-    EList getRenderKitExtension();
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRenderKitType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // RenderKitType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RendererClassType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RendererClassType.java
deleted file mode 100644
index e19bf9f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RendererClassType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Renderer Class Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RendererClassType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RendererClassType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRendererClassType()
- * @model extendedMetaData="name='renderer-class_._type' kind='simple'"
- * @generated
- */
-public interface RendererClassType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRendererClassType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererClassType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRendererClassType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererClassType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // RendererClassType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RendererExtensionType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RendererExtensionType.java
deleted file mode 100644
index 3513b44..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RendererExtensionType.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Renderer Extension Type</b></em>'.
- * <!-- end-user-doc -->
- *
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRendererExtensionType()
- * @model extendedMetaData="name='renderer-extension_._type'"
- * @generated
- */
-public interface RendererExtensionType extends ExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-} // RendererExtensionType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RendererType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RendererType.java
deleted file mode 100644
index a299c67..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RendererType.java
+++ /dev/null
@@ -1,260 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Renderer Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getComponentFamily <em>Component Family</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getRendererType <em>Renderer Type</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getRendererClass <em>Renderer Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getFacet <em>Facet</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getAttribute <em>Attribute</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getRendererExtension <em>Renderer Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRendererType()
- * @model extendedMetaData="name='renderer_._type' kind='elementOnly'"
- * @generated
- */
-public interface RendererType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Description</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Description</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>Description</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRendererType_Description()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DescriptionType" containment="true"
-	 *        extendedMetaData="kind='element' name='description' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDescription();
-
-    /**
-	 * Returns the value of the '<em><b>Display Name</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Display Name</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>Display Name</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRendererType_DisplayName()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType" containment="true"
-	 *        extendedMetaData="kind='element' name='display-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDisplayName();
-
-    /**
-	 * Returns the value of the '<em><b>Icon</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.IconType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Icon</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>Icon</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRendererType_Icon()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.IconType" containment="true"
-	 *        extendedMetaData="kind='element' name='icon' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getIcon();
-
-    /**
-	 * Returns the value of the '<em><b>Component Family</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Component Family</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Component Family</em>' containment reference.
-	 * @see #setComponentFamily(ComponentFamilyType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRendererType_ComponentFamily()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='component-family' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ComponentFamilyType getComponentFamily();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getComponentFamily <em>Component Family</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Component Family</em>' containment reference.
-	 * @see #getComponentFamily()
-	 * @generated
-	 */
-	void setComponentFamily(ComponentFamilyType value);
-
-    /**
-	 * Returns the value of the '<em><b>Renderer Type</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Renderer Type</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Renderer Type</em>' containment reference.
-	 * @see #setRendererType(RendererTypeType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRendererType_RendererType()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='renderer-type' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	RendererTypeType getRendererType();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getRendererType <em>Renderer Type</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Renderer Type</em>' containment reference.
-	 * @see #getRendererType()
-	 * @generated
-	 */
-	void setRendererType(RendererTypeType value);
-
-    /**
-	 * Returns the value of the '<em><b>Renderer Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Renderer Class</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Renderer Class</em>' containment reference.
-	 * @see #setRendererClass(RendererClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRendererType_RendererClass()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='renderer-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	RendererClassType getRendererClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getRendererClass <em>Renderer Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Renderer Class</em>' containment reference.
-	 * @see #getRendererClass()
-	 * @generated
-	 */
-	void setRendererClass(RendererClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Facet</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.FacetType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Facet</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>Facet</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRendererType_Facet()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.FacetType" containment="true"
-	 *        extendedMetaData="kind='element' name='facet' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getFacet();
-
-    /**
-	 * Returns the value of the '<em><b>Attribute</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Attribute</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>Attribute</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRendererType_Attribute()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.AttributeType" containment="true"
-	 *        extendedMetaData="kind='element' name='attribute' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getAttribute();
-
-    /**
-	 * Returns the value of the '<em><b>Renderer Extension</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.RendererExtensionType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Renderer Extension</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>Renderer Extension</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRendererType_RendererExtension()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.RendererExtensionType" containment="true"
-	 *        extendedMetaData="kind='element' name='renderer-extension' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getRendererExtension();
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRendererType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // RendererType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RendererTypeType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RendererTypeType.java
deleted file mode 100644
index bc5aafe..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/RendererTypeType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Renderer Type Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RendererTypeType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.RendererTypeType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRendererTypeType()
- * @model extendedMetaData="name='renderer-type_._type' kind='simple'"
- * @generated
- */
-public interface RendererTypeType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRendererTypeType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererTypeType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getRendererTypeType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererTypeType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // RendererTypeType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ResourceBundleType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ResourceBundleType.java
deleted file mode 100644
index ee2cd8c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ResourceBundleType.java
+++ /dev/null
@@ -1,176 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Resource Bundle Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType#getBaseName <em>Base Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType#getVar <em>Var</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getResourceBundleType()
- * @model extendedMetaData="name='resourceBundle_._type' kind='elementOnly'"
- * @generated
- */
-public interface ResourceBundleType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Description</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType}.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Description</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>Description</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getResourceBundleType_Description()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DescriptionType" containment="true"
-	 *        extendedMetaData="kind='element' name='description' namespace='##targetNamespace'"
-	 * @generated
-	 */
-    EList getDescription();
-
-    /**
-	 * Returns the value of the '<em><b>Display Name</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType}.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Display Name</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>Display Name</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getResourceBundleType_DisplayName()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType" containment="true"
-	 *        extendedMetaData="kind='element' name='display-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-    EList getDisplayName();
-
-    /**
-	 * Returns the value of the '<em><b>Icon</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.IconType}.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Icon</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>Icon</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getResourceBundleType_Icon()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.IconType" containment="true"
-	 *        extendedMetaData="kind='element' name='icon' namespace='##targetNamespace'"
-	 * @generated
-	 */
-    EList getIcon();
-
-    /**
-	 * Returns the value of the '<em><b>Base Name</b></em>' reference.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Base Name</em>' reference isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-	 * @return the value of the '<em>Base Name</em>' reference.
-	 * @see #setBaseName(BaseNameType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getResourceBundleType_BaseName()
-	 * @model extendedMetaData="kind='element' name='base-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-    BaseNameType getBaseName();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType#getBaseName <em>Base Name</em>}' reference.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Base Name</em>' reference.
-	 * @see #getBaseName()
-	 * @generated
-	 */
-    void setBaseName(BaseNameType value);
-
-    /**
-	 * Returns the value of the '<em><b>Var</b></em>' reference.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Var</em>' reference isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-	 * @return the value of the '<em>Var</em>' reference.
-	 * @see #setVar(VarType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getResourceBundleType_Var()
-	 * @model extendedMetaData="kind='element' name='var' namespace='##targetNamespace'"
-	 * @generated
-	 */
-    VarType getVar();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType#getVar <em>Var</em>}' reference.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Var</em>' reference.
-	 * @see #getVar()
-	 * @generated
-	 */
-    void setVar(VarType value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Id</em>' attribute isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getResourceBundleType_Id()
-	 * @model id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-    String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-    void setId(String value);
-
-} // ResourceBundleType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ResourceHandlerType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ResourceHandlerType.java
deleted file mode 100644
index a78949b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ResourceHandlerType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Resource Handler Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceHandlerType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceHandlerType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getResourceHandlerType()
- * @model extendedMetaData="name='resource-handler_._type' kind='simple'"
- * @generated
- */
-public interface ResourceHandlerType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getResourceHandlerType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceHandlerType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getResourceHandlerType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceHandlerType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ResourceHandlerType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/SmallIconType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/SmallIconType.java
deleted file mode 100644
index 910de54..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/SmallIconType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Small Icon Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.SmallIconType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.SmallIconType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSmallIconType()
- * @model extendedMetaData="name='small-icon_._type' kind='simple'"
- * @generated
- */
-public interface SmallIconType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSmallIconType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.SmallIconType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSmallIconType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.SmallIconType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // SmallIconType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/SourceClassType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/SourceClassType.java
deleted file mode 100644
index f5522ea..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/SourceClassType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Source Class Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.SourceClassType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.SourceClassType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSourceClassType()
- * @model extendedMetaData="name='source-class_._type' kind='simple'"
- * @generated
- */
-public interface SourceClassType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSourceClassType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.SourceClassType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSourceClassType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.SourceClassType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // SourceClassType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/StateManagerType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/StateManagerType.java
deleted file mode 100644
index 46ec765..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/StateManagerType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>State Manager Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.StateManagerType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.StateManagerType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getStateManagerType()
- * @model extendedMetaData="name='state-manager_._type' kind='simple'"
- * @generated
- */
-public interface StateManagerType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getStateManagerType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.StateManagerType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getStateManagerType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.StateManagerType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // StateManagerType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/SuggestedValueType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/SuggestedValueType.java
deleted file mode 100644
index 3b98fa3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/SuggestedValueType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Suggested Value Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.SuggestedValueType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.SuggestedValueType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSuggestedValueType()
- * @model extendedMetaData="name='suggested-value_._type' kind='simple'"
- * @generated
- */
-public interface SuggestedValueType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSuggestedValueType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.SuggestedValueType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSuggestedValueType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.SuggestedValueType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // SuggestedValueType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/SupportedLocaleType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/SupportedLocaleType.java
deleted file mode 100644
index 2f5c394..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/SupportedLocaleType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Supported Locale Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.SupportedLocaleType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.SupportedLocaleType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSupportedLocaleType()
- * @model extendedMetaData="name='supported-locale_._type' kind='simple'"
- * @generated
- */
-public interface SupportedLocaleType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSupportedLocaleType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.SupportedLocaleType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSupportedLocaleType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.SupportedLocaleType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // SupportedLocaleType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/SystemEventClassType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/SystemEventClassType.java
deleted file mode 100644
index a98e192..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/SystemEventClassType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>System Event Class Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventClassType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventClassType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSystemEventClassType()
- * @model extendedMetaData="name='system-event-class_._type' kind='simple'"
- * @generated
- */
-public interface SystemEventClassType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSystemEventClassType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventClassType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSystemEventClassType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventClassType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // SystemEventClassType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/SystemEventListenerClassType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/SystemEventListenerClassType.java
deleted file mode 100644
index fe5ebb1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/SystemEventListenerClassType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>System Event Listener Class Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerClassType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerClassType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSystemEventListenerClassType()
- * @model extendedMetaData="name='system-event-listener-class_._type' kind='simple'"
- * @generated
- */
-public interface SystemEventListenerClassType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSystemEventListenerClassType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerClassType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSystemEventListenerClassType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerClassType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // SystemEventListenerClassType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/SystemEventListenerType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/SystemEventListenerType.java
deleted file mode 100644
index 3abb1d7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/SystemEventListenerType.java
+++ /dev/null
@@ -1,151 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>System Event Listener Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType#getSystemEventListenerClass <em>System Event Listener Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType#getSystemEventClass <em>System Event Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType#getSourceClass <em>Source Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSystemEventListenerType()
- * @model extendedMetaData="name='system-event-listener_._type' kind='elementOnly'"
- * @generated
- */
-public interface SystemEventListenerType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>System Event Listener Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>System Event Listener Class</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>System Event Listener Class</em>' containment reference.
-	 * @see #setSystemEventListenerClass(SystemEventListenerClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSystemEventListenerType_SystemEventListenerClass()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='system-event-listener-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	SystemEventListenerClassType getSystemEventListenerClass();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType#getSystemEventListenerClass <em>System Event Listener Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>System Event Listener Class</em>' containment reference.
-	 * @see #getSystemEventListenerClass()
-	 * @generated
-	 */
-	void setSystemEventListenerClass(SystemEventListenerClassType value);
-
-	/**
-	 * Returns the value of the '<em><b>System Event Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>System Event Class</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>System Event Class</em>' containment reference.
-	 * @see #setSystemEventClass(SystemEventClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSystemEventListenerType_SystemEventClass()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='system-event-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	SystemEventClassType getSystemEventClass();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType#getSystemEventClass <em>System Event Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>System Event Class</em>' containment reference.
-	 * @see #getSystemEventClass()
-	 * @generated
-	 */
-	void setSystemEventClass(SystemEventClassType value);
-
-	/**
-	 * Returns the value of the '<em><b>Source Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Source Class</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>Source Class</em>' containment reference.
-	 * @see #setSourceClass(SourceClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSystemEventListenerType_SourceClass()
-	 * @model containment="true"
-	 *        extendedMetaData="kind='element' name='source-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	SourceClassType getSourceClass();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType#getSourceClass <em>Source Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Source Class</em>' containment reference.
-	 * @see #getSourceClass()
-	 * @generated
-	 */
-	void setSourceClass(SourceClassType value);
-
-	/**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getSystemEventListenerType_Id()
-	 * @model id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // SystemEventListenerType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/TagHandlerDelegateFactoryType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/TagHandlerDelegateFactoryType.java
deleted file mode 100644
index 7049c7d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/TagHandlerDelegateFactoryType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Tag Handler Delegate Factory Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.TagHandlerDelegateFactoryType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.TagHandlerDelegateFactoryType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getTagHandlerDelegateFactoryType()
- * @model extendedMetaData="name='tag-handler-delegate-factory_._type' kind='simple'"
- * @generated
- */
-public interface TagHandlerDelegateFactoryType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getTagHandlerDelegateFactoryType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.TagHandlerDelegateFactoryType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getTagHandlerDelegateFactoryType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.TagHandlerDelegateFactoryType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // TagHandlerDelegateFactoryType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ToViewIdType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ToViewIdType.java
deleted file mode 100644
index 1050610..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ToViewIdType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>To View Id Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ToViewIdType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ToViewIdType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getToViewIdType()
- * @model extendedMetaData="name='to-view-id_._type' kind='simple'"
- * @generated
- */
-public interface ToViewIdType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getToViewIdType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ToViewIdType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getToViewIdType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ToViewIdType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ToViewIdType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ValidatorClassType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ValidatorClassType.java
deleted file mode 100644
index bbbecb8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ValidatorClassType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Validator Class Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorClassType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorClassType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValidatorClassType()
- * @model extendedMetaData="name='validator-class_._type' kind='simple'"
- * @generated
- */
-public interface ValidatorClassType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValidatorClassType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorClassType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValidatorClassType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorClassType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ValidatorClassType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ValidatorExtensionType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ValidatorExtensionType.java
deleted file mode 100644
index 181de8a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ValidatorExtensionType.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Validator Extension Type</b></em>'.
- * <!-- end-user-doc -->
- *
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValidatorExtensionType()
- * @model extendedMetaData="name='validator-extension_._type'"
- * @generated
- */
-public interface ValidatorExtensionType extends ExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-} // ValidatorExtensionType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ValidatorIdType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ValidatorIdType.java
deleted file mode 100644
index fadc127..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ValidatorIdType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Validator Id Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorIdType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorIdType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValidatorIdType()
- * @model extendedMetaData="name='validator-id_._type' kind='simple'"
- * @generated
- */
-public interface ValidatorIdType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValidatorIdType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorIdType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValidatorIdType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorIdType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ValidatorIdType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ValidatorType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ValidatorType.java
deleted file mode 100644
index 38e6e5b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ValidatorType.java
+++ /dev/null
@@ -1,232 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Validator Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getValidatorId <em>Validator Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getValidatorClass <em>Validator Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getAttribute <em>Attribute</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getProperty <em>Property</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getValidatorExtension <em>Validator Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValidatorType()
- * @model extendedMetaData="name='validator_._type' kind='elementOnly'"
- * @generated
- */
-public interface ValidatorType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Description</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Description</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>Description</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValidatorType_Description()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DescriptionType" containment="true"
-	 *        extendedMetaData="kind='element' name='description' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDescription();
-
-    /**
-	 * Returns the value of the '<em><b>Display Name</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Display Name</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>Display Name</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValidatorType_DisplayName()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType" containment="true"
-	 *        extendedMetaData="kind='element' name='display-name' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getDisplayName();
-
-    /**
-	 * Returns the value of the '<em><b>Icon</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.IconType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Icon</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>Icon</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValidatorType_Icon()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.IconType" containment="true"
-	 *        extendedMetaData="kind='element' name='icon' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getIcon();
-
-    /**
-	 * Returns the value of the '<em><b>Validator Id</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Validator Id</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Validator Id</em>' containment reference.
-	 * @see #setValidatorId(ValidatorIdType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValidatorType_ValidatorId()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='validator-id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ValidatorIdType getValidatorId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getValidatorId <em>Validator Id</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Validator Id</em>' containment reference.
-	 * @see #getValidatorId()
-	 * @generated
-	 */
-	void setValidatorId(ValidatorIdType value);
-
-    /**
-	 * Returns the value of the '<em><b>Validator Class</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Validator Class</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Validator Class</em>' containment reference.
-	 * @see #setValidatorClass(ValidatorClassType)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValidatorType_ValidatorClass()
-	 * @model containment="true" required="true"
-	 *        extendedMetaData="kind='element' name='validator-class' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	ValidatorClassType getValidatorClass();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getValidatorClass <em>Validator Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Validator Class</em>' containment reference.
-	 * @see #getValidatorClass()
-	 * @generated
-	 */
-	void setValidatorClass(ValidatorClassType value);
-
-    /**
-	 * Returns the value of the '<em><b>Attribute</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Attribute</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>Attribute</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValidatorType_Attribute()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.AttributeType" containment="true"
-	 *        extendedMetaData="kind='element' name='attribute' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getAttribute();
-
-    /**
-	 * Returns the value of the '<em><b>Property</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Property</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>Property</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValidatorType_Property()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.PropertyType" containment="true"
-	 *        extendedMetaData="kind='element' name='property' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	EList getProperty();
-
-    /**
-	 * Returns the value of the '<em><b>Validator Extension</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorExtensionType}.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Validator Extension</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>Validator Extension</em>' containment reference list.
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValidatorType_ValidatorExtension()
-	 * @model type="org.eclipse.jst.jsf.facesconfig.emf.ValidatorExtensionType" containment="true"
-	 *        extendedMetaData="kind='element' name='validator-extension' namespace='##targetNamespace'"
-	 * @generated
-	 */
-    EList getValidatorExtension();
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValidatorType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ValidatorType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ValueClassType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ValueClassType.java
deleted file mode 100644
index d13be62..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ValueClassType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Value Class Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ValueClassType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ValueClassType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValueClassType()
- * @model extendedMetaData="name='value-class_._type' kind='simple'"
- * @generated
- */
-public interface ValueClassType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValueClassType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ValueClassType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValueClassType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ValueClassType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ValueClassType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ValueType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ValueType.java
deleted file mode 100644
index 5b95e85..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ValueType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Value Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ValueType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ValueType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValueType()
- * @model extendedMetaData="name='value_._type' kind='simple'"
- * @generated
- */
-public interface ValueType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValueType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ValueType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getValueType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ValueType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ValueType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/VarType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/VarType.java
deleted file mode 100644
index e23d09e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/VarType.java
+++ /dev/null
@@ -1,94 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Var Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.VarType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.VarType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getVarType()
- * @model extendedMetaData="name='var_._type' kind='simple'"
- * @generated
- */
-public interface VarType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getVarType_TextContent()
-	 * @model extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-    String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.VarType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-    void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Id</em>' attribute isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getVarType_Id()
-	 * @model id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-    String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.VarType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-    void setId(String value);
-
-} // VarType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/VariableResolverType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/VariableResolverType.java
deleted file mode 100644
index dda6b9e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/VariableResolverType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Variable Resolver Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.VariableResolverType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.VariableResolverType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getVariableResolverType()
- * @model extendedMetaData="name='variable-resolver_._type' kind='simple'"
- * @generated
- */
-public interface VariableResolverType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getVariableResolverType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.VariableResolverType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getVariableResolverType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.VariableResolverType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // VariableResolverType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ViewDeclarationLanguageFactoryType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ViewDeclarationLanguageFactoryType.java
deleted file mode 100644
index 191e462..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ViewDeclarationLanguageFactoryType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>View Declaration Language Factory Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ViewDeclarationLanguageFactoryType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ViewDeclarationLanguageFactoryType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getViewDeclarationLanguageFactoryType()
- * @model extendedMetaData="name='view-declaration-language-factory_._type' kind='simple'"
- * @generated
- */
-public interface ViewDeclarationLanguageFactoryType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getViewDeclarationLanguageFactoryType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ViewDeclarationLanguageFactoryType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getViewDeclarationLanguageFactoryType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ViewDeclarationLanguageFactoryType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ViewDeclarationLanguageFactoryType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ViewHandlerType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ViewHandlerType.java
deleted file mode 100644
index 83819f2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/ViewHandlerType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>View Handler Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ViewHandlerType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.ViewHandlerType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getViewHandlerType()
- * @model extendedMetaData="name='view-handler_._type' kind='simple'"
- * @generated
- */
-public interface ViewHandlerType extends EObject {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getViewHandlerType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ViewHandlerType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-    /**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getViewHandlerType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-    /**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.ViewHandlerType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // ViewHandlerType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/VisitContextFactoryType.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/VisitContextFactoryType.java
deleted file mode 100644
index 97b50d5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/VisitContextFactoryType.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Visit Context Factory Type</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.VisitContextFactoryType#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.VisitContextFactoryType#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getVisitContextFactoryType()
- * @model extendedMetaData="name='visit-context-factory_._type' kind='simple'"
- * @generated
- */
-public interface VisitContextFactoryType extends EObject {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * Returns the value of the '<em><b>Text Content</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Text Content</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Text Content</em>' attribute.
-	 * @see #setTextContent(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getVisitContextFactoryType_TextContent()
-	 * @model unique="false" dataType="org.eclipse.emf.ecore.xml.type.String"
-	 *        extendedMetaData="name=':0' kind='simple'"
-	 * @generated
-	 */
-	String getTextContent();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.VisitContextFactoryType#getTextContent <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Text Content</em>' attribute.
-	 * @see #getTextContent()
-	 * @generated
-	 */
-	void setTextContent(String value);
-
-	/**
-	 * Returns the value of the '<em><b>Id</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Id</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Id</em>' attribute.
-	 * @see #setId(String)
-	 * @see org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage#getVisitContextFactoryType_Id()
-	 * @model unique="false" id="true" dataType="org.eclipse.emf.ecore.xml.type.ID"
-	 *        extendedMetaData="kind='attribute' name='id' namespace='##targetNamespace'"
-	 * @generated
-	 */
-	String getId();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.jst.jsf.facesconfig.emf.VisitContextFactoryType#getId <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Id</em>' attribute.
-	 * @see #getId()
-	 * @generated
-	 */
-	void setId(String value);
-
-} // VisitContextFactoryType
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/AbsoluteOrderingTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/AbsoluteOrderingTypeImpl.java
deleted file mode 100644
index c3347fd..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/AbsoluteOrderingTypeImpl.java
+++ /dev/null
@@ -1,250 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.AbsoluteOrderingType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.NameType;
-import org.eclipse.jst.jsf.facesconfig.emf.OrderingOthersType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Absolute Ordering Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AbsoluteOrderingTypeImpl#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AbsoluteOrderingTypeImpl#getOthers <em>Others</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class AbsoluteOrderingTypeImpl extends EObjectImpl implements AbsoluteOrderingType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The cached value of the '{@link #getName() <em>Name</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getName()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList name;
-
-	/**
-	 * The cached value of the '{@link #getOthers() <em>Others</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getOthers()
-	 * @generated
-	 * @ordered
-	 */
-	protected OrderingOthersType others;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected AbsoluteOrderingTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.ABSOLUTE_ORDERING_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getName() {
-		if (name == null) {
-			name = new EObjectContainmentEList(NameType.class, this, FacesConfigPackage.ABSOLUTE_ORDERING_TYPE__NAME);
-		}
-		return name;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public OrderingOthersType getOthers() {
-		return others;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param newOthers 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * @generated NOT
-	 */
-	public NotificationChain basicSetOthers(OrderingOthersType newOthers, NotificationChain msgs) {
-		OrderingOthersType oldOthers = others;
-		others = newOthers;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ABSOLUTE_ORDERING_TYPE__OTHERS, oldOthers, newOthers);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setOthers(OrderingOthersType newOthers) {
-		if (newOthers != others) {
-			NotificationChain msgs = null;
-			if (others != null)
-				msgs = ((InternalEObject)others).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.ABSOLUTE_ORDERING_TYPE__OTHERS, null, msgs);
-			if (newOthers != null)
-				msgs = ((InternalEObject)newOthers).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.ABSOLUTE_ORDERING_TYPE__OTHERS, null, msgs);
-			msgs = basicSetOthers(newOthers, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ABSOLUTE_ORDERING_TYPE__OTHERS, newOthers, newOthers));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.ABSOLUTE_ORDERING_TYPE__NAME:
-				return ((InternalEList)getName()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.ABSOLUTE_ORDERING_TYPE__OTHERS:
-				return basicSetOthers(null, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.ABSOLUTE_ORDERING_TYPE__NAME:
-				return getName();
-			case FacesConfigPackage.ABSOLUTE_ORDERING_TYPE__OTHERS:
-				return getOthers();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.ABSOLUTE_ORDERING_TYPE__NAME:
-				getName().clear();
-				getName().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.ABSOLUTE_ORDERING_TYPE__OTHERS:
-				setOthers((OrderingOthersType)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.ABSOLUTE_ORDERING_TYPE__NAME:
-				getName().clear();
-				return;
-			case FacesConfigPackage.ABSOLUTE_ORDERING_TYPE__OTHERS:
-				setOthers((OrderingOthersType)null);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.ABSOLUTE_ORDERING_TYPE__NAME:
-				return name != null && !name.isEmpty();
-			case FacesConfigPackage.ABSOLUTE_ORDERING_TYPE__OTHERS:
-				return others != null;
-		}
-		return super.eIsSet(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (names: "); //$NON-NLS-1$
-		for (final Object oname : getName()) {
-			NameType nameType = (NameType)oname;
-			result.append(nameType.getTextContent());
-			result.append(',');
-		}
-		result.append(')');
-//		result.append(" (id: "); //$NON-NLS-1$
-//		result.append(id);
-//		result.append(')');
-		return result.toString();
-	}
-
-} //AbsoluteOrderingTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ActionListenerTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ActionListenerTypeImpl.java
deleted file mode 100644
index ad8360e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ActionListenerTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.ActionListenerType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Action Listener Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ActionListenerTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ActionListenerTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ActionListenerTypeImpl extends EObjectImpl implements ActionListenerType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ActionListenerTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.ACTION_LISTENER_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ACTION_LISTENER_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ACTION_LISTENER_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.ACTION_LISTENER_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.ACTION_LISTENER_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.ACTION_LISTENER_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.ACTION_LISTENER_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.ACTION_LISTENER_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.ACTION_LISTENER_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.ACTION_LISTENER_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.ACTION_LISTENER_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ActionListenerTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ApplicationExtensionTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ApplicationExtensionTypeImpl.java
deleted file mode 100644
index 2b74cf4..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ApplicationExtensionTypeImpl.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.jst.jsf.facesconfig.emf.ApplicationExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Application Extension Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * </p>
- *
- * @generated
- */
-public class ApplicationExtensionTypeImpl extends ExtensionTypeImpl implements ApplicationExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    @SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected ApplicationExtensionTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.APPLICATION_EXTENSION_TYPE;
-	}
-
-} //ApplicationExtensionTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ApplicationFactoryTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ApplicationFactoryTypeImpl.java
deleted file mode 100644
index 4280a62..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ApplicationFactoryTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.ApplicationFactoryType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Application Factory Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationFactoryTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationFactoryTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ApplicationFactoryTypeImpl extends EObjectImpl implements ApplicationFactoryType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ApplicationFactoryTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.APPLICATION_FACTORY_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.APPLICATION_FACTORY_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.APPLICATION_FACTORY_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.APPLICATION_FACTORY_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.APPLICATION_FACTORY_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.APPLICATION_FACTORY_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.APPLICATION_FACTORY_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.APPLICATION_FACTORY_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.APPLICATION_FACTORY_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.APPLICATION_FACTORY_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.APPLICATION_FACTORY_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ApplicationFactoryTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ApplicationTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ApplicationTypeImpl.java
deleted file mode 100644
index de8affd..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ApplicationTypeImpl.java
+++ /dev/null
@@ -1,735 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.EObjectResolvingEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.ActionListenerType;
-import org.eclipse.jst.jsf.facesconfig.emf.ApplicationExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.ApplicationType;
-import org.eclipse.jst.jsf.facesconfig.emf.DefaultRenderKitIdType;
-import org.eclipse.jst.jsf.facesconfig.emf.DefaultValidatorsType;
-import org.eclipse.jst.jsf.facesconfig.emf.ELResolverType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType;
-import org.eclipse.jst.jsf.facesconfig.emf.MessageBundleType;
-import org.eclipse.jst.jsf.facesconfig.emf.NavigationHandlerType;
-import org.eclipse.jst.jsf.facesconfig.emf.PropertyResolverType;
-import org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType;
-import org.eclipse.jst.jsf.facesconfig.emf.ResourceHandlerType;
-import org.eclipse.jst.jsf.facesconfig.emf.StateManagerType;
-import org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType;
-import org.eclipse.jst.jsf.facesconfig.emf.VariableResolverType;
-import org.eclipse.jst.jsf.facesconfig.emf.ViewHandlerType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Application Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl#getActionListener <em>Action Listener</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl#getDefaultRenderKitId <em>Default Render Kit Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl#getMessageBundle <em>Message Bundle</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl#getNavigationHandler <em>Navigation Handler</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl#getViewHandler <em>View Handler</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl#getStateManager <em>State Manager</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl#getELResolver <em>EL Resolver</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl#getPropertyResolver <em>Property Resolver</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl#getVariableResolver <em>Variable Resolver</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl#getResourceHandler <em>Resource Handler</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl#getSystemEventListener <em>System Event Listener</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl#getLocaleConfig <em>Locale Config</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl#getResourceBundle <em>Resource Bundle</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl#getApplicationExtension <em>Application Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl#getDefaultValidators <em>Default Validators</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ApplicationTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ApplicationTypeImpl extends EObjectImpl implements ApplicationType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getActionListener() <em>Action Listener</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getActionListener()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList actionListener;
-
-    /**
-	 * The cached value of the '{@link #getDefaultRenderKitId() <em>Default Render Kit Id</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDefaultRenderKitId()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList defaultRenderKitId;
-
-    /**
-	 * The cached value of the '{@link #getMessageBundle() <em>Message Bundle</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getMessageBundle()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList messageBundle;
-
-    /**
-	 * The cached value of the '{@link #getNavigationHandler() <em>Navigation Handler</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getNavigationHandler()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList navigationHandler;
-
-    /**
-	 * The cached value of the '{@link #getViewHandler() <em>View Handler</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getViewHandler()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList viewHandler;
-
-    /**
-	 * The cached value of the '{@link #getStateManager() <em>State Manager</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getStateManager()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList stateManager;
-
-    /**
-	 * The cached value of the '{@link #getELResolver() <em>EL Resolver</em>}' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getELResolver()
-	 * @generated
-	 * @ordered
-	 */
-    protected EList eLResolver;
-
-				/**
-	 * The cached value of the '{@link #getPropertyResolver() <em>Property Resolver</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getPropertyResolver()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList propertyResolver;
-
-				/**
-	 * The cached value of the '{@link #getVariableResolver() <em>Variable Resolver</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getVariableResolver()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList variableResolver;
-
-				/**
-	 * The cached value of the '{@link #getResourceHandler() <em>Resource Handler</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getResourceHandler()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList resourceHandler;
-
-				/**
-	 * The cached value of the '{@link #getSystemEventListener() <em>System Event Listener</em>}' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getSystemEventListener()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList systemEventListener;
-
-				/**
-	 * The cached value of the '{@link #getLocaleConfig() <em>Locale Config</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getLocaleConfig()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList localeConfig;
-
-    /**
-	 * The cached value of the '{@link #getResourceBundle() <em>Resource Bundle</em>}' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getResourceBundle()
-	 * @generated
-	 * @ordered
-	 */
-    protected EList resourceBundle;
-
-    /**
-	 * The cached value of the '{@link #getApplicationExtension() <em>Application Extension</em>}' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getApplicationExtension()
-	 * @generated
-	 * @ordered
-	 */
-    protected EList applicationExtension;
-
-    /**
-	 * The cached value of the '{@link #getDefaultValidators() <em>Default Validators</em>}' reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDefaultValidators()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList defaultValidators;
-
-				/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-				/**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ApplicationTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.APPLICATION_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getActionListener() {
-		if (actionListener == null) {
-			actionListener = new EObjectContainmentEList(ActionListenerType.class, this, FacesConfigPackage.APPLICATION_TYPE__ACTION_LISTENER);
-		}
-		return actionListener;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDefaultRenderKitId() {
-		if (defaultRenderKitId == null) {
-			defaultRenderKitId = new EObjectContainmentEList(DefaultRenderKitIdType.class, this, FacesConfigPackage.APPLICATION_TYPE__DEFAULT_RENDER_KIT_ID);
-		}
-		return defaultRenderKitId;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getMessageBundle() {
-		if (messageBundle == null) {
-			messageBundle = new EObjectContainmentEList(MessageBundleType.class, this, FacesConfigPackage.APPLICATION_TYPE__MESSAGE_BUNDLE);
-		}
-		return messageBundle;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getNavigationHandler() {
-		if (navigationHandler == null) {
-			navigationHandler = new EObjectContainmentEList(NavigationHandlerType.class, this, FacesConfigPackage.APPLICATION_TYPE__NAVIGATION_HANDLER);
-		}
-		return navigationHandler;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getViewHandler() {
-		if (viewHandler == null) {
-			viewHandler = new EObjectContainmentEList(ViewHandlerType.class, this, FacesConfigPackage.APPLICATION_TYPE__VIEW_HANDLER);
-		}
-		return viewHandler;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getStateManager() {
-		if (stateManager == null) {
-			stateManager = new EObjectContainmentEList(StateManagerType.class, this, FacesConfigPackage.APPLICATION_TYPE__STATE_MANAGER);
-		}
-		return stateManager;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getPropertyResolver() {
-		if (propertyResolver == null) {
-			propertyResolver = new EObjectContainmentEList(PropertyResolverType.class, this, FacesConfigPackage.APPLICATION_TYPE__PROPERTY_RESOLVER);
-		}
-		return propertyResolver;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getVariableResolver() {
-		if (variableResolver == null) {
-			variableResolver = new EObjectContainmentEList(VariableResolverType.class, this, FacesConfigPackage.APPLICATION_TYPE__VARIABLE_RESOLVER);
-		}
-		return variableResolver;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getResourceHandler() {
-		if (resourceHandler == null) {
-			resourceHandler = new EObjectContainmentEList(ResourceHandlerType.class, this, FacesConfigPackage.APPLICATION_TYPE__RESOURCE_HANDLER);
-		}
-		return resourceHandler;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getSystemEventListener() {
-		if (systemEventListener == null) {
-			systemEventListener = new EObjectResolvingEList(SystemEventListenerType.class, this, FacesConfigPackage.APPLICATION_TYPE__SYSTEM_EVENT_LISTENER);
-		}
-		return systemEventListener;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getLocaleConfig() {
-		if (localeConfig == null) {
-			localeConfig = new EObjectContainmentEList(LocaleConfigType.class, this, FacesConfigPackage.APPLICATION_TYPE__LOCALE_CONFIG);
-		}
-		return localeConfig;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.APPLICATION_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EList getELResolver() {
-		if (eLResolver == null) {
-			eLResolver = new EObjectResolvingEList(ELResolverType.class, this, FacesConfigPackage.APPLICATION_TYPE__EL_RESOLVER);
-		}
-		return eLResolver;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EList getResourceBundle() {
-		if (resourceBundle == null) {
-			resourceBundle = new EObjectResolvingEList(ResourceBundleType.class, this, FacesConfigPackage.APPLICATION_TYPE__RESOURCE_BUNDLE);
-		}
-		return resourceBundle;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EList getApplicationExtension() {
-		if (applicationExtension == null) {
-			applicationExtension = new EObjectResolvingEList(ApplicationExtensionType.class, this, FacesConfigPackage.APPLICATION_TYPE__APPLICATION_EXTENSION);
-		}
-		return applicationExtension;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDefaultValidators() {
-		if (defaultValidators == null) {
-			defaultValidators = new EObjectResolvingEList(DefaultValidatorsType.class, this, FacesConfigPackage.APPLICATION_TYPE__DEFAULT_VALIDATORS);
-		}
-		return defaultValidators;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.APPLICATION_TYPE__ACTION_LISTENER:
-				return ((InternalEList)getActionListener()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.APPLICATION_TYPE__DEFAULT_RENDER_KIT_ID:
-				return ((InternalEList)getDefaultRenderKitId()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.APPLICATION_TYPE__MESSAGE_BUNDLE:
-				return ((InternalEList)getMessageBundle()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.APPLICATION_TYPE__NAVIGATION_HANDLER:
-				return ((InternalEList)getNavigationHandler()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.APPLICATION_TYPE__VIEW_HANDLER:
-				return ((InternalEList)getViewHandler()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.APPLICATION_TYPE__STATE_MANAGER:
-				return ((InternalEList)getStateManager()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.APPLICATION_TYPE__PROPERTY_RESOLVER:
-				return ((InternalEList)getPropertyResolver()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.APPLICATION_TYPE__VARIABLE_RESOLVER:
-				return ((InternalEList)getVariableResolver()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.APPLICATION_TYPE__RESOURCE_HANDLER:
-				return ((InternalEList)getResourceHandler()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.APPLICATION_TYPE__LOCALE_CONFIG:
-				return ((InternalEList)getLocaleConfig()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.APPLICATION_TYPE__ACTION_LISTENER:
-				return getActionListener();
-			case FacesConfigPackage.APPLICATION_TYPE__DEFAULT_RENDER_KIT_ID:
-				return getDefaultRenderKitId();
-			case FacesConfigPackage.APPLICATION_TYPE__MESSAGE_BUNDLE:
-				return getMessageBundle();
-			case FacesConfigPackage.APPLICATION_TYPE__NAVIGATION_HANDLER:
-				return getNavigationHandler();
-			case FacesConfigPackage.APPLICATION_TYPE__VIEW_HANDLER:
-				return getViewHandler();
-			case FacesConfigPackage.APPLICATION_TYPE__STATE_MANAGER:
-				return getStateManager();
-			case FacesConfigPackage.APPLICATION_TYPE__EL_RESOLVER:
-				return getELResolver();
-			case FacesConfigPackage.APPLICATION_TYPE__PROPERTY_RESOLVER:
-				return getPropertyResolver();
-			case FacesConfigPackage.APPLICATION_TYPE__VARIABLE_RESOLVER:
-				return getVariableResolver();
-			case FacesConfigPackage.APPLICATION_TYPE__RESOURCE_HANDLER:
-				return getResourceHandler();
-			case FacesConfigPackage.APPLICATION_TYPE__SYSTEM_EVENT_LISTENER:
-				return getSystemEventListener();
-			case FacesConfigPackage.APPLICATION_TYPE__LOCALE_CONFIG:
-				return getLocaleConfig();
-			case FacesConfigPackage.APPLICATION_TYPE__RESOURCE_BUNDLE:
-				return getResourceBundle();
-			case FacesConfigPackage.APPLICATION_TYPE__APPLICATION_EXTENSION:
-				return getApplicationExtension();
-			case FacesConfigPackage.APPLICATION_TYPE__DEFAULT_VALIDATORS:
-				return getDefaultValidators();
-			case FacesConfigPackage.APPLICATION_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.APPLICATION_TYPE__ACTION_LISTENER:
-				getActionListener().clear();
-				getActionListener().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__DEFAULT_RENDER_KIT_ID:
-				getDefaultRenderKitId().clear();
-				getDefaultRenderKitId().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__MESSAGE_BUNDLE:
-				getMessageBundle().clear();
-				getMessageBundle().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__NAVIGATION_HANDLER:
-				getNavigationHandler().clear();
-				getNavigationHandler().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__VIEW_HANDLER:
-				getViewHandler().clear();
-				getViewHandler().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__STATE_MANAGER:
-				getStateManager().clear();
-				getStateManager().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__EL_RESOLVER:
-				getELResolver().clear();
-				getELResolver().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__PROPERTY_RESOLVER:
-				getPropertyResolver().clear();
-				getPropertyResolver().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__VARIABLE_RESOLVER:
-				getVariableResolver().clear();
-				getVariableResolver().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__RESOURCE_HANDLER:
-				getResourceHandler().clear();
-				getResourceHandler().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__SYSTEM_EVENT_LISTENER:
-				getSystemEventListener().clear();
-				getSystemEventListener().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__LOCALE_CONFIG:
-				getLocaleConfig().clear();
-				getLocaleConfig().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__RESOURCE_BUNDLE:
-				getResourceBundle().clear();
-				getResourceBundle().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__APPLICATION_EXTENSION:
-				getApplicationExtension().clear();
-				getApplicationExtension().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__DEFAULT_VALIDATORS:
-				getDefaultValidators().clear();
-				getDefaultValidators().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.APPLICATION_TYPE__ACTION_LISTENER:
-				getActionListener().clear();
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__DEFAULT_RENDER_KIT_ID:
-				getDefaultRenderKitId().clear();
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__MESSAGE_BUNDLE:
-				getMessageBundle().clear();
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__NAVIGATION_HANDLER:
-				getNavigationHandler().clear();
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__VIEW_HANDLER:
-				getViewHandler().clear();
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__STATE_MANAGER:
-				getStateManager().clear();
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__EL_RESOLVER:
-				getELResolver().clear();
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__PROPERTY_RESOLVER:
-				getPropertyResolver().clear();
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__VARIABLE_RESOLVER:
-				getVariableResolver().clear();
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__RESOURCE_HANDLER:
-				getResourceHandler().clear();
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__SYSTEM_EVENT_LISTENER:
-				getSystemEventListener().clear();
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__LOCALE_CONFIG:
-				getLocaleConfig().clear();
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__RESOURCE_BUNDLE:
-				getResourceBundle().clear();
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__APPLICATION_EXTENSION:
-				getApplicationExtension().clear();
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__DEFAULT_VALIDATORS:
-				getDefaultValidators().clear();
-				return;
-			case FacesConfigPackage.APPLICATION_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.APPLICATION_TYPE__ACTION_LISTENER:
-				return actionListener != null && !actionListener.isEmpty();
-			case FacesConfigPackage.APPLICATION_TYPE__DEFAULT_RENDER_KIT_ID:
-				return defaultRenderKitId != null && !defaultRenderKitId.isEmpty();
-			case FacesConfigPackage.APPLICATION_TYPE__MESSAGE_BUNDLE:
-				return messageBundle != null && !messageBundle.isEmpty();
-			case FacesConfigPackage.APPLICATION_TYPE__NAVIGATION_HANDLER:
-				return navigationHandler != null && !navigationHandler.isEmpty();
-			case FacesConfigPackage.APPLICATION_TYPE__VIEW_HANDLER:
-				return viewHandler != null && !viewHandler.isEmpty();
-			case FacesConfigPackage.APPLICATION_TYPE__STATE_MANAGER:
-				return stateManager != null && !stateManager.isEmpty();
-			case FacesConfigPackage.APPLICATION_TYPE__EL_RESOLVER:
-				return eLResolver != null && !eLResolver.isEmpty();
-			case FacesConfigPackage.APPLICATION_TYPE__PROPERTY_RESOLVER:
-				return propertyResolver != null && !propertyResolver.isEmpty();
-			case FacesConfigPackage.APPLICATION_TYPE__VARIABLE_RESOLVER:
-				return variableResolver != null && !variableResolver.isEmpty();
-			case FacesConfigPackage.APPLICATION_TYPE__RESOURCE_HANDLER:
-				return resourceHandler != null && !resourceHandler.isEmpty();
-			case FacesConfigPackage.APPLICATION_TYPE__SYSTEM_EVENT_LISTENER:
-				return systemEventListener != null && !systemEventListener.isEmpty();
-			case FacesConfigPackage.APPLICATION_TYPE__LOCALE_CONFIG:
-				return localeConfig != null && !localeConfig.isEmpty();
-			case FacesConfigPackage.APPLICATION_TYPE__RESOURCE_BUNDLE:
-				return resourceBundle != null && !resourceBundle.isEmpty();
-			case FacesConfigPackage.APPLICATION_TYPE__APPLICATION_EXTENSION:
-				return applicationExtension != null && !applicationExtension.isEmpty();
-			case FacesConfigPackage.APPLICATION_TYPE__DEFAULT_VALIDATORS:
-				return defaultValidators != null && !defaultValidators.isEmpty();
-			case FacesConfigPackage.APPLICATION_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ApplicationTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/AttributeClassTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/AttributeClassTypeImpl.java
deleted file mode 100644
index 5f390f7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/AttributeClassTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.AttributeClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Attribute Class Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeClassTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeClassTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class AttributeClassTypeImpl extends EObjectImpl implements AttributeClassType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected AttributeClassTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.ATTRIBUTE_CLASS_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ATTRIBUTE_CLASS_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ATTRIBUTE_CLASS_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.ATTRIBUTE_CLASS_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.ATTRIBUTE_CLASS_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.ATTRIBUTE_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.ATTRIBUTE_CLASS_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.ATTRIBUTE_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.ATTRIBUTE_CLASS_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.ATTRIBUTE_CLASS_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.ATTRIBUTE_CLASS_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //AttributeClassTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/AttributeExtensionTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/AttributeExtensionTypeImpl.java
deleted file mode 100644
index af1ea26..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/AttributeExtensionTypeImpl.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.jst.jsf.facesconfig.emf.AttributeExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Attribute Extension Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * </p>
- *
- * @generated
- */
-public class AttributeExtensionTypeImpl extends ExtensionTypeImpl implements AttributeExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected AttributeExtensionTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.ATTRIBUTE_EXTENSION_TYPE;
-	}
-
-} //AttributeExtensionTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/AttributeNameTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/AttributeNameTypeImpl.java
deleted file mode 100644
index 87f3a86..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/AttributeNameTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.AttributeNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Attribute Name Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeNameTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeNameTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class AttributeNameTypeImpl extends EObjectImpl implements AttributeNameType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected AttributeNameTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.ATTRIBUTE_NAME_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ATTRIBUTE_NAME_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ATTRIBUTE_NAME_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.ATTRIBUTE_NAME_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.ATTRIBUTE_NAME_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.ATTRIBUTE_NAME_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.ATTRIBUTE_NAME_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.ATTRIBUTE_NAME_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.ATTRIBUTE_NAME_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.ATTRIBUTE_NAME_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.ATTRIBUTE_NAME_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //AttributeNameTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/AttributeTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/AttributeTypeImpl.java
deleted file mode 100644
index d7e8709..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/AttributeTypeImpl.java
+++ /dev/null
@@ -1,617 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.AttributeClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.AttributeExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.AttributeNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.AttributeType;
-import org.eclipse.jst.jsf.facesconfig.emf.DefaultValueType;
-import org.eclipse.jst.jsf.facesconfig.emf.DescriptionType;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.IconType;
-import org.eclipse.jst.jsf.facesconfig.emf.SuggestedValueType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Attribute Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeTypeImpl#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeTypeImpl#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeTypeImpl#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeTypeImpl#getAttributeName <em>Attribute Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeTypeImpl#getAttributeClass <em>Attribute Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeTypeImpl#getDefaultValue <em>Default Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeTypeImpl#getSuggestedValue <em>Suggested Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeTypeImpl#getAttributeExtension <em>Attribute Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.AttributeTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class AttributeTypeImpl extends EObjectImpl implements AttributeType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getDescription() <em>Description</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDescription()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList description;
-
-    /**
-	 * The cached value of the '{@link #getDisplayName() <em>Display Name</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDisplayName()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList displayName;
-
-    /**
-	 * The cached value of the '{@link #getIcon() <em>Icon</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getIcon()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList icon;
-
-    /**
-	 * The cached value of the '{@link #getAttributeName() <em>Attribute Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getAttributeName()
-	 * @generated
-	 * @ordered
-	 */
-	protected AttributeNameType attributeName;
-
-    /**
-	 * The cached value of the '{@link #getAttributeClass() <em>Attribute Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getAttributeClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected AttributeClassType attributeClass;
-
-    /**
-	 * The cached value of the '{@link #getDefaultValue() <em>Default Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDefaultValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected DefaultValueType defaultValue;
-
-    /**
-	 * The cached value of the '{@link #getSuggestedValue() <em>Suggested Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getSuggestedValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected SuggestedValueType suggestedValue;
-
-    /**
-	 * The cached value of the '{@link #getAttributeExtension() <em>Attribute Extension</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getAttributeExtension()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList attributeExtension;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected AttributeTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.ATTRIBUTE_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDescription() {
-		if (description == null) {
-			description = new EObjectContainmentEList(DescriptionType.class, this, FacesConfigPackage.ATTRIBUTE_TYPE__DESCRIPTION);
-		}
-		return description;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDisplayName() {
-		if (displayName == null) {
-			displayName = new EObjectContainmentEList(DisplayNameType.class, this, FacesConfigPackage.ATTRIBUTE_TYPE__DISPLAY_NAME);
-		}
-		return displayName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getIcon() {
-		if (icon == null) {
-			icon = new EObjectContainmentEList(IconType.class, this, FacesConfigPackage.ATTRIBUTE_TYPE__ICON);
-		}
-		return icon;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public AttributeNameType getAttributeName() {
-		return attributeName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newAttributeName 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetAttributeName(AttributeNameType newAttributeName, NotificationChain msgs) {
-		AttributeNameType oldAttributeName = attributeName;
-		attributeName = newAttributeName;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_NAME, oldAttributeName, newAttributeName);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setAttributeName(AttributeNameType newAttributeName) {
-		if (newAttributeName != attributeName) {
-			NotificationChain msgs = null;
-			if (attributeName != null)
-				msgs = ((InternalEObject)attributeName).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_NAME, null, msgs);
-			if (newAttributeName != null)
-				msgs = ((InternalEObject)newAttributeName).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_NAME, null, msgs);
-			msgs = basicSetAttributeName(newAttributeName, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_NAME, newAttributeName, newAttributeName));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public AttributeClassType getAttributeClass() {
-		return attributeClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newAttributeClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetAttributeClass(AttributeClassType newAttributeClass, NotificationChain msgs) {
-		AttributeClassType oldAttributeClass = attributeClass;
-		attributeClass = newAttributeClass;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_CLASS, oldAttributeClass, newAttributeClass);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setAttributeClass(AttributeClassType newAttributeClass) {
-		if (newAttributeClass != attributeClass) {
-			NotificationChain msgs = null;
-			if (attributeClass != null)
-				msgs = ((InternalEObject)attributeClass).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_CLASS, null, msgs);
-			if (newAttributeClass != null)
-				msgs = ((InternalEObject)newAttributeClass).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_CLASS, null, msgs);
-			msgs = basicSetAttributeClass(newAttributeClass, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_CLASS, newAttributeClass, newAttributeClass));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DefaultValueType getDefaultValue() {
-		return defaultValue;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newDefaultValue 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetDefaultValue(DefaultValueType newDefaultValue, NotificationChain msgs) {
-		DefaultValueType oldDefaultValue = defaultValue;
-		defaultValue = newDefaultValue;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ATTRIBUTE_TYPE__DEFAULT_VALUE, oldDefaultValue, newDefaultValue);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setDefaultValue(DefaultValueType newDefaultValue) {
-		if (newDefaultValue != defaultValue) {
-			NotificationChain msgs = null;
-			if (defaultValue != null)
-				msgs = ((InternalEObject)defaultValue).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.ATTRIBUTE_TYPE__DEFAULT_VALUE, null, msgs);
-			if (newDefaultValue != null)
-				msgs = ((InternalEObject)newDefaultValue).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.ATTRIBUTE_TYPE__DEFAULT_VALUE, null, msgs);
-			msgs = basicSetDefaultValue(newDefaultValue, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ATTRIBUTE_TYPE__DEFAULT_VALUE, newDefaultValue, newDefaultValue));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SuggestedValueType getSuggestedValue() {
-		return suggestedValue;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newSuggestedValue 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetSuggestedValue(SuggestedValueType newSuggestedValue, NotificationChain msgs) {
-		SuggestedValueType oldSuggestedValue = suggestedValue;
-		suggestedValue = newSuggestedValue;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ATTRIBUTE_TYPE__SUGGESTED_VALUE, oldSuggestedValue, newSuggestedValue);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setSuggestedValue(SuggestedValueType newSuggestedValue) {
-		if (newSuggestedValue != suggestedValue) {
-			NotificationChain msgs = null;
-			if (suggestedValue != null)
-				msgs = ((InternalEObject)suggestedValue).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.ATTRIBUTE_TYPE__SUGGESTED_VALUE, null, msgs);
-			if (newSuggestedValue != null)
-				msgs = ((InternalEObject)newSuggestedValue).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.ATTRIBUTE_TYPE__SUGGESTED_VALUE, null, msgs);
-			msgs = basicSetSuggestedValue(newSuggestedValue, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ATTRIBUTE_TYPE__SUGGESTED_VALUE, newSuggestedValue, newSuggestedValue));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getAttributeExtension() {
-		if (attributeExtension == null) {
-			attributeExtension = new EObjectContainmentEList(AttributeExtensionType.class, this, FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_EXTENSION);
-		}
-		return attributeExtension;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ATTRIBUTE_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.ATTRIBUTE_TYPE__DESCRIPTION:
-				return ((InternalEList)getDescription()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.ATTRIBUTE_TYPE__DISPLAY_NAME:
-				return ((InternalEList)getDisplayName()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ICON:
-				return ((InternalEList)getIcon()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_NAME:
-				return basicSetAttributeName(null, msgs);
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_CLASS:
-				return basicSetAttributeClass(null, msgs);
-			case FacesConfigPackage.ATTRIBUTE_TYPE__DEFAULT_VALUE:
-				return basicSetDefaultValue(null, msgs);
-			case FacesConfigPackage.ATTRIBUTE_TYPE__SUGGESTED_VALUE:
-				return basicSetSuggestedValue(null, msgs);
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_EXTENSION:
-				return ((InternalEList)getAttributeExtension()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.ATTRIBUTE_TYPE__DESCRIPTION:
-				return getDescription();
-			case FacesConfigPackage.ATTRIBUTE_TYPE__DISPLAY_NAME:
-				return getDisplayName();
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ICON:
-				return getIcon();
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_NAME:
-				return getAttributeName();
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_CLASS:
-				return getAttributeClass();
-			case FacesConfigPackage.ATTRIBUTE_TYPE__DEFAULT_VALUE:
-				return getDefaultValue();
-			case FacesConfigPackage.ATTRIBUTE_TYPE__SUGGESTED_VALUE:
-				return getSuggestedValue();
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_EXTENSION:
-				return getAttributeExtension();
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.ATTRIBUTE_TYPE__DESCRIPTION:
-				getDescription().clear();
-				getDescription().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.ATTRIBUTE_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				getDisplayName().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ICON:
-				getIcon().clear();
-				getIcon().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_NAME:
-				setAttributeName((AttributeNameType)newValue);
-				return;
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_CLASS:
-				setAttributeClass((AttributeClassType)newValue);
-				return;
-			case FacesConfigPackage.ATTRIBUTE_TYPE__DEFAULT_VALUE:
-				setDefaultValue((DefaultValueType)newValue);
-				return;
-			case FacesConfigPackage.ATTRIBUTE_TYPE__SUGGESTED_VALUE:
-				setSuggestedValue((SuggestedValueType)newValue);
-				return;
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_EXTENSION:
-				getAttributeExtension().clear();
-				getAttributeExtension().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.ATTRIBUTE_TYPE__DESCRIPTION:
-				getDescription().clear();
-				return;
-			case FacesConfigPackage.ATTRIBUTE_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				return;
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ICON:
-				getIcon().clear();
-				return;
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_NAME:
-				setAttributeName((AttributeNameType)null);
-				return;
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_CLASS:
-				setAttributeClass((AttributeClassType)null);
-				return;
-			case FacesConfigPackage.ATTRIBUTE_TYPE__DEFAULT_VALUE:
-				setDefaultValue((DefaultValueType)null);
-				return;
-			case FacesConfigPackage.ATTRIBUTE_TYPE__SUGGESTED_VALUE:
-				setSuggestedValue((SuggestedValueType)null);
-				return;
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_EXTENSION:
-				getAttributeExtension().clear();
-				return;
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.ATTRIBUTE_TYPE__DESCRIPTION:
-				return description != null && !description.isEmpty();
-			case FacesConfigPackage.ATTRIBUTE_TYPE__DISPLAY_NAME:
-				return displayName != null && !displayName.isEmpty();
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ICON:
-				return icon != null && !icon.isEmpty();
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_NAME:
-				return attributeName != null;
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_CLASS:
-				return attributeClass != null;
-			case FacesConfigPackage.ATTRIBUTE_TYPE__DEFAULT_VALUE:
-				return defaultValue != null;
-			case FacesConfigPackage.ATTRIBUTE_TYPE__SUGGESTED_VALUE:
-				return suggestedValue != null;
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ATTRIBUTE_EXTENSION:
-				return attributeExtension != null && !attributeExtension.isEmpty();
-			case FacesConfigPackage.ATTRIBUTE_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //AttributeTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/BaseNameTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/BaseNameTypeImpl.java
deleted file mode 100644
index 91ce976..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/BaseNameTypeImpl.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.BaseNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Base Name Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BaseNameTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BaseNameTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class BaseNameTypeImpl extends EObjectImpl implements BaseNameType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-    protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-    protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-    protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-    protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected BaseNameTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.BASE_NAME_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.BASE_NAME_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.BASE_NAME_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.BASE_NAME_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.BASE_NAME_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.BASE_NAME_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.BASE_NAME_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.BASE_NAME_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.BASE_NAME_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.BASE_NAME_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.BASE_NAME_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-    public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //BaseNameTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/BehaviorClassTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/BehaviorClassTypeImpl.java
deleted file mode 100644
index 2909d63..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/BehaviorClassTypeImpl.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.BehaviorClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Behavior Class Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorClassTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorClassTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class BehaviorClassTypeImpl extends EObjectImpl implements BehaviorClassType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected BehaviorClassTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.BEHAVIOR_CLASS_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.BEHAVIOR_CLASS_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.BEHAVIOR_CLASS_TYPE__ID, oldId, id));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.BEHAVIOR_CLASS_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.BEHAVIOR_CLASS_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.BEHAVIOR_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.BEHAVIOR_CLASS_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.BEHAVIOR_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.BEHAVIOR_CLASS_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.BEHAVIOR_CLASS_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.BEHAVIOR_CLASS_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //BehaviorClassTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/BehaviorExtensionTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/BehaviorExtensionTypeImpl.java
deleted file mode 100644
index 902b255..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/BehaviorExtensionTypeImpl.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.jst.jsf.facesconfig.emf.BehaviorExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Behavior Extension Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * </p>
- *
- * @generated
- */
-public class BehaviorExtensionTypeImpl extends ExtensionTypeImpl implements BehaviorExtensionType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected BehaviorExtensionTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.BEHAVIOR_EXTENSION_TYPE;
-	}
-
-} //BehaviorExtensionTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/BehaviorIdTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/BehaviorIdTypeImpl.java
deleted file mode 100644
index 7eae39c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/BehaviorIdTypeImpl.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.BehaviorIdType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Behavior Id Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorIdTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorIdTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class BehaviorIdTypeImpl extends EObjectImpl implements BehaviorIdType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected BehaviorIdTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.BEHAVIOR_ID_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.BEHAVIOR_ID_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.BEHAVIOR_ID_TYPE__ID, oldId, id));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.BEHAVIOR_ID_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.BEHAVIOR_ID_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.BEHAVIOR_ID_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.BEHAVIOR_ID_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.BEHAVIOR_ID_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.BEHAVIOR_ID_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.BEHAVIOR_ID_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.BEHAVIOR_ID_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //BehaviorIdTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/BehaviorTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/BehaviorTypeImpl.java
deleted file mode 100644
index f37d470..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/BehaviorTypeImpl.java
+++ /dev/null
@@ -1,483 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.AttributeType;
-import org.eclipse.jst.jsf.facesconfig.emf.BehaviorClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.BehaviorExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.BehaviorIdType;
-import org.eclipse.jst.jsf.facesconfig.emf.BehaviorType;
-import org.eclipse.jst.jsf.facesconfig.emf.DescriptionType;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.IconType;
-import org.eclipse.jst.jsf.facesconfig.emf.PropertyType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Behavior Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorTypeImpl#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorTypeImpl#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorTypeImpl#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorTypeImpl#getBehaviorId <em>Behavior Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorTypeImpl#getBehaviorClass <em>Behavior Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorTypeImpl#getAttribute <em>Attribute</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorTypeImpl#getProperty <em>Property</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.BehaviorTypeImpl#getBehaviorExtension <em>Behavior Extension</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class BehaviorTypeImpl extends EObjectImpl implements BehaviorType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The cached value of the '{@link #getDescription() <em>Description</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDescription()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList description;
-
-	/**
-	 * The cached value of the '{@link #getDisplayName() <em>Display Name</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDisplayName()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList displayName;
-
-	/**
-	 * The cached value of the '{@link #getIcon() <em>Icon</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getIcon()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList icon;
-
-	/**
-	 * The cached value of the '{@link #getBehaviorId() <em>Behavior Id</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getBehaviorId()
-	 * @generated
-	 * @ordered
-	 */
-	protected BehaviorIdType behaviorId;
-
-	/**
-	 * The cached value of the '{@link #getBehaviorClass() <em>Behavior Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getBehaviorClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected BehaviorClassType behaviorClass;
-
-	/**
-	 * The cached value of the '{@link #getAttribute() <em>Attribute</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getAttribute()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList attribute;
-
-	/**
-	 * The cached value of the '{@link #getProperty() <em>Property</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getProperty()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList property;
-
-	/**
-	 * The cached value of the '{@link #getBehaviorExtension() <em>Behavior Extension</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getBehaviorExtension()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList behaviorExtension;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected BehaviorTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.BEHAVIOR_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDescription() {
-		if (description == null) {
-			description = new EObjectContainmentEList(DescriptionType.class, this, FacesConfigPackage.BEHAVIOR_TYPE__DESCRIPTION);
-		}
-		return description;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDisplayName() {
-		if (displayName == null) {
-			displayName = new EObjectContainmentEList(DisplayNameType.class, this, FacesConfigPackage.BEHAVIOR_TYPE__DISPLAY_NAME);
-		}
-		return displayName;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getIcon() {
-		if (icon == null) {
-			icon = new EObjectContainmentEList(IconType.class, this, FacesConfigPackage.BEHAVIOR_TYPE__ICON);
-		}
-		return icon;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public BehaviorIdType getBehaviorId() {
-		return behaviorId;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param newBehaviorId 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * @generated NOT
-	 */
-	public NotificationChain basicSetBehaviorId(BehaviorIdType newBehaviorId, NotificationChain msgs) {
-		BehaviorIdType oldBehaviorId = behaviorId;
-		behaviorId = newBehaviorId;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_ID, oldBehaviorId, newBehaviorId);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setBehaviorId(BehaviorIdType newBehaviorId) {
-		if (newBehaviorId != behaviorId) {
-			NotificationChain msgs = null;
-			if (behaviorId != null)
-				msgs = ((InternalEObject)behaviorId).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_ID, null, msgs);
-			if (newBehaviorId != null)
-				msgs = ((InternalEObject)newBehaviorId).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_ID, null, msgs);
-			msgs = basicSetBehaviorId(newBehaviorId, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_ID, newBehaviorId, newBehaviorId));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public BehaviorClassType getBehaviorClass() {
-		return behaviorClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param newBehaviorClass 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * @generated NOT
-	 */
-	public NotificationChain basicSetBehaviorClass(BehaviorClassType newBehaviorClass, NotificationChain msgs) {
-		BehaviorClassType oldBehaviorClass = behaviorClass;
-		behaviorClass = newBehaviorClass;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_CLASS, oldBehaviorClass, newBehaviorClass);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setBehaviorClass(BehaviorClassType newBehaviorClass) {
-		if (newBehaviorClass != behaviorClass) {
-			NotificationChain msgs = null;
-			if (behaviorClass != null)
-				msgs = ((InternalEObject)behaviorClass).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_CLASS, null, msgs);
-			if (newBehaviorClass != null)
-				msgs = ((InternalEObject)newBehaviorClass).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_CLASS, null, msgs);
-			msgs = basicSetBehaviorClass(newBehaviorClass, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_CLASS, newBehaviorClass, newBehaviorClass));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getAttribute() {
-		if (attribute == null) {
-			attribute = new EObjectContainmentEList(AttributeType.class, this, FacesConfigPackage.BEHAVIOR_TYPE__ATTRIBUTE);
-		}
-		return attribute;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getProperty() {
-		if (property == null) {
-			property = new EObjectContainmentEList(PropertyType.class, this, FacesConfigPackage.BEHAVIOR_TYPE__PROPERTY);
-		}
-		return property;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getBehaviorExtension() {
-		if (behaviorExtension == null) {
-			behaviorExtension = new EObjectContainmentEList(BehaviorExtensionType.class, this, FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_EXTENSION);
-		}
-		return behaviorExtension;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.BEHAVIOR_TYPE__DESCRIPTION:
-				return ((InternalEList)getDescription()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.BEHAVIOR_TYPE__DISPLAY_NAME:
-				return ((InternalEList)getDisplayName()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.BEHAVIOR_TYPE__ICON:
-				return ((InternalEList)getIcon()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_ID:
-				return basicSetBehaviorId(null, msgs);
-			case FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_CLASS:
-				return basicSetBehaviorClass(null, msgs);
-			case FacesConfigPackage.BEHAVIOR_TYPE__ATTRIBUTE:
-				return ((InternalEList)getAttribute()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.BEHAVIOR_TYPE__PROPERTY:
-				return ((InternalEList)getProperty()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_EXTENSION:
-				return ((InternalEList)getBehaviorExtension()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.BEHAVIOR_TYPE__DESCRIPTION:
-				return getDescription();
-			case FacesConfigPackage.BEHAVIOR_TYPE__DISPLAY_NAME:
-				return getDisplayName();
-			case FacesConfigPackage.BEHAVIOR_TYPE__ICON:
-				return getIcon();
-			case FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_ID:
-				return getBehaviorId();
-			case FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_CLASS:
-				return getBehaviorClass();
-			case FacesConfigPackage.BEHAVIOR_TYPE__ATTRIBUTE:
-				return getAttribute();
-			case FacesConfigPackage.BEHAVIOR_TYPE__PROPERTY:
-				return getProperty();
-			case FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_EXTENSION:
-				return getBehaviorExtension();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.BEHAVIOR_TYPE__DESCRIPTION:
-				getDescription().clear();
-				getDescription().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.BEHAVIOR_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				getDisplayName().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.BEHAVIOR_TYPE__ICON:
-				getIcon().clear();
-				getIcon().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_ID:
-				setBehaviorId((BehaviorIdType)newValue);
-				return;
-			case FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_CLASS:
-				setBehaviorClass((BehaviorClassType)newValue);
-				return;
-			case FacesConfigPackage.BEHAVIOR_TYPE__ATTRIBUTE:
-				getAttribute().clear();
-				getAttribute().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.BEHAVIOR_TYPE__PROPERTY:
-				getProperty().clear();
-				getProperty().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_EXTENSION:
-				getBehaviorExtension().clear();
-				getBehaviorExtension().addAll((Collection)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.BEHAVIOR_TYPE__DESCRIPTION:
-				getDescription().clear();
-				return;
-			case FacesConfigPackage.BEHAVIOR_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				return;
-			case FacesConfigPackage.BEHAVIOR_TYPE__ICON:
-				getIcon().clear();
-				return;
-			case FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_ID:
-				setBehaviorId((BehaviorIdType)null);
-				return;
-			case FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_CLASS:
-				setBehaviorClass((BehaviorClassType)null);
-				return;
-			case FacesConfigPackage.BEHAVIOR_TYPE__ATTRIBUTE:
-				getAttribute().clear();
-				return;
-			case FacesConfigPackage.BEHAVIOR_TYPE__PROPERTY:
-				getProperty().clear();
-				return;
-			case FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_EXTENSION:
-				getBehaviorExtension().clear();
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.BEHAVIOR_TYPE__DESCRIPTION:
-				return description != null && !description.isEmpty();
-			case FacesConfigPackage.BEHAVIOR_TYPE__DISPLAY_NAME:
-				return displayName != null && !displayName.isEmpty();
-			case FacesConfigPackage.BEHAVIOR_TYPE__ICON:
-				return icon != null && !icon.isEmpty();
-			case FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_ID:
-				return behaviorId != null;
-			case FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_CLASS:
-				return behaviorClass != null;
-			case FacesConfigPackage.BEHAVIOR_TYPE__ATTRIBUTE:
-				return attribute != null && !attribute.isEmpty();
-			case FacesConfigPackage.BEHAVIOR_TYPE__PROPERTY:
-				return property != null && !property.isEmpty();
-			case FacesConfigPackage.BEHAVIOR_TYPE__BEHAVIOR_EXTENSION:
-				return behaviorExtension != null && !behaviorExtension.isEmpty();
-		}
-		return super.eIsSet(featureID);
-	}
-
-} //BehaviorTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ClientBehaviorRendererClassTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ClientBehaviorRendererClassTypeImpl.java
deleted file mode 100644
index 1190621..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ClientBehaviorRendererClassTypeImpl.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Client Behavior Renderer Class Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ClientBehaviorRendererClassTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ClientBehaviorRendererClassTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ClientBehaviorRendererClassTypeImpl extends EObjectImpl implements ClientBehaviorRendererClassType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ClientBehaviorRendererClassTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE__ID, oldId, id));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ClientBehaviorRendererClassTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ClientBehaviorRendererTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ClientBehaviorRendererTypeImpl.java
deleted file mode 100644
index 96921d7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ClientBehaviorRendererTypeImpl.java
+++ /dev/null
@@ -1,258 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererType;
-import org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererTypeType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Client Behavior Renderer Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ClientBehaviorRendererTypeImpl#getClientBehaviorRendererType <em>Client Behavior Renderer Type</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ClientBehaviorRendererTypeImpl#getClientBehaviorRendererClass <em>Client Behavior Renderer Class</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ClientBehaviorRendererTypeImpl extends EObjectImpl implements ClientBehaviorRendererType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The cached value of the '{@link #getClientBehaviorRendererType() <em>Client Behavior Renderer Type</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getClientBehaviorRendererType()
-	 * @generated
-	 * @ordered
-	 */
-	protected ClientBehaviorRendererTypeType clientBehaviorRendererType;
-
-	/**
-	 * The cached value of the '{@link #getClientBehaviorRendererClass() <em>Client Behavior Renderer Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getClientBehaviorRendererClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected ClientBehaviorRendererClassType clientBehaviorRendererClass;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ClientBehaviorRendererTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.CLIENT_BEHAVIOR_RENDERER_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ClientBehaviorRendererTypeType getClientBehaviorRendererType() {
-		return clientBehaviorRendererType;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * 
-	 * @param newClientBehaviorRendererType 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetClientBehaviorRendererType(ClientBehaviorRendererTypeType newClientBehaviorRendererType, NotificationChain msgs) {
-		ClientBehaviorRendererTypeType oldClientBehaviorRendererType = clientBehaviorRendererType;
-		clientBehaviorRendererType = newClientBehaviorRendererType;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_TYPE, oldClientBehaviorRendererType, newClientBehaviorRendererType);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setClientBehaviorRendererType(ClientBehaviorRendererTypeType newClientBehaviorRendererType) {
-		if (newClientBehaviorRendererType != clientBehaviorRendererType) {
-			NotificationChain msgs = null;
-			if (clientBehaviorRendererType != null)
-				msgs = ((InternalEObject)clientBehaviorRendererType).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_TYPE, null, msgs);
-			if (newClientBehaviorRendererType != null)
-				msgs = ((InternalEObject)newClientBehaviorRendererType).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_TYPE, null, msgs);
-			msgs = basicSetClientBehaviorRendererType(newClientBehaviorRendererType, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_TYPE, newClientBehaviorRendererType, newClientBehaviorRendererType));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ClientBehaviorRendererClassType getClientBehaviorRendererClass() {
-		return clientBehaviorRendererClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * 
-	 * @param newClientBehaviorRendererClass 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetClientBehaviorRendererClass(ClientBehaviorRendererClassType newClientBehaviorRendererClass, NotificationChain msgs) {
-		ClientBehaviorRendererClassType oldClientBehaviorRendererClass = clientBehaviorRendererClass;
-		clientBehaviorRendererClass = newClientBehaviorRendererClass;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_CLASS, oldClientBehaviorRendererClass, newClientBehaviorRendererClass);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setClientBehaviorRendererClass(ClientBehaviorRendererClassType newClientBehaviorRendererClass) {
-		if (newClientBehaviorRendererClass != clientBehaviorRendererClass) {
-			NotificationChain msgs = null;
-			if (clientBehaviorRendererClass != null)
-				msgs = ((InternalEObject)clientBehaviorRendererClass).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_CLASS, null, msgs);
-			if (newClientBehaviorRendererClass != null)
-				msgs = ((InternalEObject)newClientBehaviorRendererClass).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_CLASS, null, msgs);
-			msgs = basicSetClientBehaviorRendererClass(newClientBehaviorRendererClass, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_CLASS, newClientBehaviorRendererClass, newClientBehaviorRendererClass));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_TYPE:
-				return basicSetClientBehaviorRendererType(null, msgs);
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_CLASS:
-				return basicSetClientBehaviorRendererClass(null, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_TYPE:
-				return getClientBehaviorRendererType();
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_CLASS:
-				return getClientBehaviorRendererClass();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_TYPE:
-				setClientBehaviorRendererType((ClientBehaviorRendererTypeType)newValue);
-				return;
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_CLASS:
-				setClientBehaviorRendererClass((ClientBehaviorRendererClassType)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_TYPE:
-				setClientBehaviorRendererType((ClientBehaviorRendererTypeType)null);
-				return;
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_CLASS:
-				setClientBehaviorRendererClass((ClientBehaviorRendererClassType)null);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_TYPE:
-				return clientBehaviorRendererType != null;
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_CLASS:
-				return clientBehaviorRendererClass != null;
-		}
-		return super.eIsSet(featureID);
-	}
-
-} //ClientBehaviorRendererTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ClientBehaviorRendererTypeTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ClientBehaviorRendererTypeTypeImpl.java
deleted file mode 100644
index 5ee57a7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ClientBehaviorRendererTypeTypeImpl.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererTypeType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Client Behavior Renderer Type Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ClientBehaviorRendererTypeTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ClientBehaviorRendererTypeTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ClientBehaviorRendererTypeTypeImpl extends EObjectImpl implements ClientBehaviorRendererTypeType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ClientBehaviorRendererTypeTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE__ID, oldId, id));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ClientBehaviorRendererTypeTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ComponentClassTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ComponentClassTypeImpl.java
deleted file mode 100644
index 54b1f1a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ComponentClassTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.ComponentClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Component Class Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentClassTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentClassTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ComponentClassTypeImpl extends EObjectImpl implements ComponentClassType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ComponentClassTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.COMPONENT_CLASS_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.COMPONENT_CLASS_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.COMPONENT_CLASS_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.COMPONENT_CLASS_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.COMPONENT_CLASS_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.COMPONENT_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.COMPONENT_CLASS_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.COMPONENT_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.COMPONENT_CLASS_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.COMPONENT_CLASS_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.COMPONENT_CLASS_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ComponentClassTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ComponentExtensionTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ComponentExtensionTypeImpl.java
deleted file mode 100644
index f55a19d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ComponentExtensionTypeImpl.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.jst.jsf.facesconfig.emf.ComponentExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Component Extension Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * </p>
- *
- * @generated
- */
-public class ComponentExtensionTypeImpl extends ExtensionTypeImpl implements ComponentExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ComponentExtensionTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.COMPONENT_EXTENSION_TYPE;
-	}
-
-} //ComponentExtensionTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ComponentFamilyTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ComponentFamilyTypeImpl.java
deleted file mode 100644
index 7f3bdb1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ComponentFamilyTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.ComponentFamilyType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Component Family Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentFamilyTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentFamilyTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ComponentFamilyTypeImpl extends EObjectImpl implements ComponentFamilyType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ComponentFamilyTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.COMPONENT_FAMILY_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.COMPONENT_FAMILY_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.COMPONENT_FAMILY_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.COMPONENT_FAMILY_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.COMPONENT_FAMILY_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.COMPONENT_FAMILY_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.COMPONENT_FAMILY_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.COMPONENT_FAMILY_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.COMPONENT_FAMILY_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.COMPONENT_FAMILY_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.COMPONENT_FAMILY_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ComponentFamilyTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ComponentTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ComponentTypeImpl.java
deleted file mode 100644
index 304ebe4..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ComponentTypeImpl.java
+++ /dev/null
@@ -1,588 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.AttributeType;
-import org.eclipse.jst.jsf.facesconfig.emf.ComponentClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.ComponentExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.ComponentType;
-import org.eclipse.jst.jsf.facesconfig.emf.ComponentTypeType;
-import org.eclipse.jst.jsf.facesconfig.emf.DescriptionType;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FacetType;
-import org.eclipse.jst.jsf.facesconfig.emf.IconType;
-import org.eclipse.jst.jsf.facesconfig.emf.PropertyType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Component Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeImpl#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeImpl#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeImpl#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeImpl#getComponentType <em>Component Type</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeImpl#getComponentClass <em>Component Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeImpl#getFacet <em>Facet</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeImpl#getAttribute <em>Attribute</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeImpl#getProperty <em>Property</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeImpl#getComponentExtension <em>Component Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ComponentTypeImpl extends EObjectImpl implements ComponentType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getDescription() <em>Description</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDescription()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList description;
-
-    /**
-	 * The cached value of the '{@link #getDisplayName() <em>Display Name</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDisplayName()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList displayName;
-
-    /**
-	 * The cached value of the '{@link #getIcon() <em>Icon</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getIcon()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList icon;
-
-    /**
-	 * The cached value of the '{@link #getComponentType() <em>Component Type</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getComponentType()
-	 * @generated
-	 * @ordered
-	 */
-	protected ComponentTypeType componentType;
-
-    /**
-	 * The cached value of the '{@link #getComponentClass() <em>Component Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getComponentClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected ComponentClassType componentClass;
-
-    /**
-	 * The cached value of the '{@link #getFacet() <em>Facet</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getFacet()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList facet;
-
-    /**
-	 * The cached value of the '{@link #getAttribute() <em>Attribute</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getAttribute()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList attribute;
-
-    /**
-	 * The cached value of the '{@link #getProperty() <em>Property</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getProperty()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList property;
-
-    /**
-	 * The cached value of the '{@link #getComponentExtension() <em>Component Extension</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getComponentExtension()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList componentExtension;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ComponentTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.COMPONENT_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDescription() {
-		if (description == null) {
-			description = new EObjectContainmentEList(DescriptionType.class, this, FacesConfigPackage.COMPONENT_TYPE__DESCRIPTION);
-		}
-		return description;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDisplayName() {
-		if (displayName == null) {
-			displayName = new EObjectContainmentEList(DisplayNameType.class, this, FacesConfigPackage.COMPONENT_TYPE__DISPLAY_NAME);
-		}
-		return displayName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getIcon() {
-		if (icon == null) {
-			icon = new EObjectContainmentEList(IconType.class, this, FacesConfigPackage.COMPONENT_TYPE__ICON);
-		}
-		return icon;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ComponentTypeType getComponentType() {
-		return componentType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newComponentType 
-     * @param msgs 
-     * @return the notification chain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetComponentType(ComponentTypeType newComponentType, NotificationChain msgs) {
-		ComponentTypeType oldComponentType = componentType;
-		componentType = newComponentType;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.COMPONENT_TYPE__COMPONENT_TYPE, oldComponentType, newComponentType);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setComponentType(ComponentTypeType newComponentType) {
-		if (newComponentType != componentType) {
-			NotificationChain msgs = null;
-			if (componentType != null)
-				msgs = ((InternalEObject)componentType).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.COMPONENT_TYPE__COMPONENT_TYPE, null, msgs);
-			if (newComponentType != null)
-				msgs = ((InternalEObject)newComponentType).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.COMPONENT_TYPE__COMPONENT_TYPE, null, msgs);
-			msgs = basicSetComponentType(newComponentType, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.COMPONENT_TYPE__COMPONENT_TYPE, newComponentType, newComponentType));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ComponentClassType getComponentClass() {
-		return componentClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newComponentClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetComponentClass(ComponentClassType newComponentClass, NotificationChain msgs) {
-		ComponentClassType oldComponentClass = componentClass;
-		componentClass = newComponentClass;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.COMPONENT_TYPE__COMPONENT_CLASS, oldComponentClass, newComponentClass);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setComponentClass(ComponentClassType newComponentClass) {
-		if (newComponentClass != componentClass) {
-			NotificationChain msgs = null;
-			if (componentClass != null)
-				msgs = ((InternalEObject)componentClass).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.COMPONENT_TYPE__COMPONENT_CLASS, null, msgs);
-			if (newComponentClass != null)
-				msgs = ((InternalEObject)newComponentClass).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.COMPONENT_TYPE__COMPONENT_CLASS, null, msgs);
-			msgs = basicSetComponentClass(newComponentClass, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.COMPONENT_TYPE__COMPONENT_CLASS, newComponentClass, newComponentClass));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getFacet() {
-		if (facet == null) {
-			facet = new EObjectContainmentEList(FacetType.class, this, FacesConfigPackage.COMPONENT_TYPE__FACET);
-		}
-		return facet;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getAttribute() {
-		if (attribute == null) {
-			attribute = new EObjectContainmentEList(AttributeType.class, this, FacesConfigPackage.COMPONENT_TYPE__ATTRIBUTE);
-		}
-		return attribute;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getProperty() {
-		if (property == null) {
-			property = new EObjectContainmentEList(PropertyType.class, this, FacesConfigPackage.COMPONENT_TYPE__PROPERTY);
-		}
-		return property;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getComponentExtension() {
-		if (componentExtension == null) {
-			componentExtension = new EObjectContainmentEList(ComponentExtensionType.class, this, FacesConfigPackage.COMPONENT_TYPE__COMPONENT_EXTENSION);
-		}
-		return componentExtension;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.COMPONENT_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.COMPONENT_TYPE__DESCRIPTION:
-				return ((InternalEList)getDescription()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.COMPONENT_TYPE__DISPLAY_NAME:
-				return ((InternalEList)getDisplayName()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.COMPONENT_TYPE__ICON:
-				return ((InternalEList)getIcon()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.COMPONENT_TYPE__COMPONENT_TYPE:
-				return basicSetComponentType(null, msgs);
-			case FacesConfigPackage.COMPONENT_TYPE__COMPONENT_CLASS:
-				return basicSetComponentClass(null, msgs);
-			case FacesConfigPackage.COMPONENT_TYPE__FACET:
-				return ((InternalEList)getFacet()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.COMPONENT_TYPE__ATTRIBUTE:
-				return ((InternalEList)getAttribute()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.COMPONENT_TYPE__PROPERTY:
-				return ((InternalEList)getProperty()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.COMPONENT_TYPE__COMPONENT_EXTENSION:
-				return ((InternalEList)getComponentExtension()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.COMPONENT_TYPE__DESCRIPTION:
-				return getDescription();
-			case FacesConfigPackage.COMPONENT_TYPE__DISPLAY_NAME:
-				return getDisplayName();
-			case FacesConfigPackage.COMPONENT_TYPE__ICON:
-				return getIcon();
-			case FacesConfigPackage.COMPONENT_TYPE__COMPONENT_TYPE:
-				return getComponentType();
-			case FacesConfigPackage.COMPONENT_TYPE__COMPONENT_CLASS:
-				return getComponentClass();
-			case FacesConfigPackage.COMPONENT_TYPE__FACET:
-				return getFacet();
-			case FacesConfigPackage.COMPONENT_TYPE__ATTRIBUTE:
-				return getAttribute();
-			case FacesConfigPackage.COMPONENT_TYPE__PROPERTY:
-				return getProperty();
-			case FacesConfigPackage.COMPONENT_TYPE__COMPONENT_EXTENSION:
-				return getComponentExtension();
-			case FacesConfigPackage.COMPONENT_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.COMPONENT_TYPE__DESCRIPTION:
-				getDescription().clear();
-				getDescription().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.COMPONENT_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				getDisplayName().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.COMPONENT_TYPE__ICON:
-				getIcon().clear();
-				getIcon().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.COMPONENT_TYPE__COMPONENT_TYPE:
-				setComponentType((ComponentTypeType)newValue);
-				return;
-			case FacesConfigPackage.COMPONENT_TYPE__COMPONENT_CLASS:
-				setComponentClass((ComponentClassType)newValue);
-				return;
-			case FacesConfigPackage.COMPONENT_TYPE__FACET:
-				getFacet().clear();
-				getFacet().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.COMPONENT_TYPE__ATTRIBUTE:
-				getAttribute().clear();
-				getAttribute().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.COMPONENT_TYPE__PROPERTY:
-				getProperty().clear();
-				getProperty().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.COMPONENT_TYPE__COMPONENT_EXTENSION:
-				getComponentExtension().clear();
-				getComponentExtension().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.COMPONENT_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.COMPONENT_TYPE__DESCRIPTION:
-				getDescription().clear();
-				return;
-			case FacesConfigPackage.COMPONENT_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				return;
-			case FacesConfigPackage.COMPONENT_TYPE__ICON:
-				getIcon().clear();
-				return;
-			case FacesConfigPackage.COMPONENT_TYPE__COMPONENT_TYPE:
-				setComponentType((ComponentTypeType)null);
-				return;
-			case FacesConfigPackage.COMPONENT_TYPE__COMPONENT_CLASS:
-				setComponentClass((ComponentClassType)null);
-				return;
-			case FacesConfigPackage.COMPONENT_TYPE__FACET:
-				getFacet().clear();
-				return;
-			case FacesConfigPackage.COMPONENT_TYPE__ATTRIBUTE:
-				getAttribute().clear();
-				return;
-			case FacesConfigPackage.COMPONENT_TYPE__PROPERTY:
-				getProperty().clear();
-				return;
-			case FacesConfigPackage.COMPONENT_TYPE__COMPONENT_EXTENSION:
-				getComponentExtension().clear();
-				return;
-			case FacesConfigPackage.COMPONENT_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.COMPONENT_TYPE__DESCRIPTION:
-				return description != null && !description.isEmpty();
-			case FacesConfigPackage.COMPONENT_TYPE__DISPLAY_NAME:
-				return displayName != null && !displayName.isEmpty();
-			case FacesConfigPackage.COMPONENT_TYPE__ICON:
-				return icon != null && !icon.isEmpty();
-			case FacesConfigPackage.COMPONENT_TYPE__COMPONENT_TYPE:
-				return componentType != null;
-			case FacesConfigPackage.COMPONENT_TYPE__COMPONENT_CLASS:
-				return componentClass != null;
-			case FacesConfigPackage.COMPONENT_TYPE__FACET:
-				return facet != null && !facet.isEmpty();
-			case FacesConfigPackage.COMPONENT_TYPE__ATTRIBUTE:
-				return attribute != null && !attribute.isEmpty();
-			case FacesConfigPackage.COMPONENT_TYPE__PROPERTY:
-				return property != null && !property.isEmpty();
-			case FacesConfigPackage.COMPONENT_TYPE__COMPONENT_EXTENSION:
-				return componentExtension != null && !componentExtension.isEmpty();
-			case FacesConfigPackage.COMPONENT_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ComponentTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ComponentTypeTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ComponentTypeTypeImpl.java
deleted file mode 100644
index 56bfb41..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ComponentTypeTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.ComponentTypeType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Component Type Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ComponentTypeTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ComponentTypeTypeImpl extends EObjectImpl implements ComponentTypeType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ComponentTypeTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.COMPONENT_TYPE_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.COMPONENT_TYPE_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.COMPONENT_TYPE_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.COMPONENT_TYPE_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.COMPONENT_TYPE_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.COMPONENT_TYPE_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.COMPONENT_TYPE_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.COMPONENT_TYPE_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.COMPONENT_TYPE_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.COMPONENT_TYPE_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.COMPONENT_TYPE_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ComponentTypeTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ConverterClassTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ConverterClassTypeImpl.java
deleted file mode 100644
index f57f9f8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ConverterClassTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.ConverterClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Converter Class Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterClassTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterClassTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ConverterClassTypeImpl extends EObjectImpl implements ConverterClassType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ConverterClassTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.CONVERTER_CLASS_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.CONVERTER_CLASS_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.CONVERTER_CLASS_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.CONVERTER_CLASS_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.CONVERTER_CLASS_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.CONVERTER_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.CONVERTER_CLASS_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.CONVERTER_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.CONVERTER_CLASS_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.CONVERTER_CLASS_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.CONVERTER_CLASS_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ConverterClassTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ConverterExtensionTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ConverterExtensionTypeImpl.java
deleted file mode 100644
index 3b8b38d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ConverterExtensionTypeImpl.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.jst.jsf.facesconfig.emf.ConverterExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Converter Extension Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * </p>
- *
- * @generated
- */
-public class ConverterExtensionTypeImpl extends ExtensionTypeImpl implements ConverterExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    @SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected ConverterExtensionTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.CONVERTER_EXTENSION_TYPE;
-	}
-
-} //ConverterExtensionTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ConverterForClassTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ConverterForClassTypeImpl.java
deleted file mode 100644
index 659359c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ConverterForClassTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.ConverterForClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Converter For Class Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterForClassTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterForClassTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ConverterForClassTypeImpl extends EObjectImpl implements ConverterForClassType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ConverterForClassTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.CONVERTER_FOR_CLASS_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.CONVERTER_FOR_CLASS_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.CONVERTER_FOR_CLASS_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.CONVERTER_FOR_CLASS_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.CONVERTER_FOR_CLASS_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.CONVERTER_FOR_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.CONVERTER_FOR_CLASS_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.CONVERTER_FOR_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.CONVERTER_FOR_CLASS_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.CONVERTER_FOR_CLASS_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.CONVERTER_FOR_CLASS_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ConverterForClassTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ConverterIdTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ConverterIdTypeImpl.java
deleted file mode 100644
index 82a4997..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ConverterIdTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.ConverterIdType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Converter Id Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterIdTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterIdTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ConverterIdTypeImpl extends EObjectImpl implements ConverterIdType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ConverterIdTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.CONVERTER_ID_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.CONVERTER_ID_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.CONVERTER_ID_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.CONVERTER_ID_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.CONVERTER_ID_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.CONVERTER_ID_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.CONVERTER_ID_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.CONVERTER_ID_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.CONVERTER_ID_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.CONVERTER_ID_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.CONVERTER_ID_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ConverterIdTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ConverterTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ConverterTypeImpl.java
deleted file mode 100644
index fe331ee..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ConverterTypeImpl.java
+++ /dev/null
@@ -1,621 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.AttributeType;
-import org.eclipse.jst.jsf.facesconfig.emf.ConverterClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.ConverterExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.ConverterForClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.ConverterIdType;
-import org.eclipse.jst.jsf.facesconfig.emf.ConverterType;
-import org.eclipse.jst.jsf.facesconfig.emf.DescriptionType;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.IconType;
-import org.eclipse.jst.jsf.facesconfig.emf.PropertyType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Converter Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterTypeImpl#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterTypeImpl#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterTypeImpl#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterTypeImpl#getConverterId <em>Converter Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterTypeImpl#getConverterForClass <em>Converter For Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterTypeImpl#getConverterClass <em>Converter Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterTypeImpl#getAttribute <em>Attribute</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterTypeImpl#getProperty <em>Property</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterTypeImpl#getConverterExtension <em>Converter Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ConverterTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ConverterTypeImpl extends EObjectImpl implements ConverterType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getDescription() <em>Description</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDescription()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList description;
-
-    /**
-	 * The cached value of the '{@link #getDisplayName() <em>Display Name</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDisplayName()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList displayName;
-
-    /**
-	 * The cached value of the '{@link #getIcon() <em>Icon</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getIcon()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList icon;
-
-    /**
-	 * The cached value of the '{@link #getConverterId() <em>Converter Id</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getConverterId()
-	 * @generated
-	 * @ordered
-	 */
-	protected ConverterIdType converterId;
-
-    /**
-	 * The cached value of the '{@link #getConverterForClass() <em>Converter For Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getConverterForClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected ConverterForClassType converterForClass;
-
-    /**
-	 * The cached value of the '{@link #getConverterClass() <em>Converter Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getConverterClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected ConverterClassType converterClass;
-
-    /**
-	 * The cached value of the '{@link #getAttribute() <em>Attribute</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getAttribute()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList attribute;
-
-    /**
-	 * The cached value of the '{@link #getProperty() <em>Property</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getProperty()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList property;
-
-    /**
-	 * The cached value of the '{@link #getConverterExtension() <em>Converter Extension</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getConverterExtension()
-	 * @generated
-	 * @ordered
-	 */
-    protected EList converterExtension;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ConverterTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.CONVERTER_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDescription() {
-		if (description == null) {
-			description = new EObjectContainmentEList(DescriptionType.class, this, FacesConfigPackage.CONVERTER_TYPE__DESCRIPTION);
-		}
-		return description;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDisplayName() {
-		if (displayName == null) {
-			displayName = new EObjectContainmentEList(DisplayNameType.class, this, FacesConfigPackage.CONVERTER_TYPE__DISPLAY_NAME);
-		}
-		return displayName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getIcon() {
-		if (icon == null) {
-			icon = new EObjectContainmentEList(IconType.class, this, FacesConfigPackage.CONVERTER_TYPE__ICON);
-		}
-		return icon;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConverterIdType getConverterId() {
-		return converterId;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newConverterId 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetConverterId(ConverterIdType newConverterId, NotificationChain msgs) {
-		ConverterIdType oldConverterId = converterId;
-		converterId = newConverterId;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.CONVERTER_TYPE__CONVERTER_ID, oldConverterId, newConverterId);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setConverterId(ConverterIdType newConverterId) {
-		if (newConverterId != converterId) {
-			NotificationChain msgs = null;
-			if (converterId != null)
-				msgs = ((InternalEObject)converterId).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.CONVERTER_TYPE__CONVERTER_ID, null, msgs);
-			if (newConverterId != null)
-				msgs = ((InternalEObject)newConverterId).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.CONVERTER_TYPE__CONVERTER_ID, null, msgs);
-			msgs = basicSetConverterId(newConverterId, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.CONVERTER_TYPE__CONVERTER_ID, newConverterId, newConverterId));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConverterForClassType getConverterForClass() {
-		return converterForClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newConverterForClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetConverterForClass(ConverterForClassType newConverterForClass, NotificationChain msgs) {
-		ConverterForClassType oldConverterForClass = converterForClass;
-		converterForClass = newConverterForClass;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.CONVERTER_TYPE__CONVERTER_FOR_CLASS, oldConverterForClass, newConverterForClass);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setConverterForClass(ConverterForClassType newConverterForClass) {
-		if (newConverterForClass != converterForClass) {
-			NotificationChain msgs = null;
-			if (converterForClass != null)
-				msgs = ((InternalEObject)converterForClass).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.CONVERTER_TYPE__CONVERTER_FOR_CLASS, null, msgs);
-			if (newConverterForClass != null)
-				msgs = ((InternalEObject)newConverterForClass).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.CONVERTER_TYPE__CONVERTER_FOR_CLASS, null, msgs);
-			msgs = basicSetConverterForClass(newConverterForClass, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.CONVERTER_TYPE__CONVERTER_FOR_CLASS, newConverterForClass, newConverterForClass));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConverterClassType getConverterClass() {
-		return converterClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newConverterClass 
-     * @param msgs 
-     * @return  
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetConverterClass(ConverterClassType newConverterClass, NotificationChain msgs) {
-		ConverterClassType oldConverterClass = converterClass;
-		converterClass = newConverterClass;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.CONVERTER_TYPE__CONVERTER_CLASS, oldConverterClass, newConverterClass);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setConverterClass(ConverterClassType newConverterClass) {
-		if (newConverterClass != converterClass) {
-			NotificationChain msgs = null;
-			if (converterClass != null)
-				msgs = ((InternalEObject)converterClass).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.CONVERTER_TYPE__CONVERTER_CLASS, null, msgs);
-			if (newConverterClass != null)
-				msgs = ((InternalEObject)newConverterClass).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.CONVERTER_TYPE__CONVERTER_CLASS, null, msgs);
-			msgs = basicSetConverterClass(newConverterClass, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.CONVERTER_TYPE__CONVERTER_CLASS, newConverterClass, newConverterClass));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getAttribute() {
-		if (attribute == null) {
-			attribute = new EObjectContainmentEList(AttributeType.class, this, FacesConfigPackage.CONVERTER_TYPE__ATTRIBUTE);
-		}
-		return attribute;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getProperty() {
-		if (property == null) {
-			property = new EObjectContainmentEList(PropertyType.class, this, FacesConfigPackage.CONVERTER_TYPE__PROPERTY);
-		}
-		return property;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EList getConverterExtension() {
-		if (converterExtension == null) {
-			converterExtension = new EObjectContainmentEList(ConverterExtensionType.class, this, FacesConfigPackage.CONVERTER_TYPE__CONVERTER_EXTENSION);
-		}
-		return converterExtension;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.CONVERTER_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.CONVERTER_TYPE__DESCRIPTION:
-				return ((InternalEList)getDescription()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.CONVERTER_TYPE__DISPLAY_NAME:
-				return ((InternalEList)getDisplayName()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.CONVERTER_TYPE__ICON:
-				return ((InternalEList)getIcon()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_ID:
-				return basicSetConverterId(null, msgs);
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_FOR_CLASS:
-				return basicSetConverterForClass(null, msgs);
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_CLASS:
-				return basicSetConverterClass(null, msgs);
-			case FacesConfigPackage.CONVERTER_TYPE__ATTRIBUTE:
-				return ((InternalEList)getAttribute()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.CONVERTER_TYPE__PROPERTY:
-				return ((InternalEList)getProperty()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_EXTENSION:
-				return ((InternalEList)getConverterExtension()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.CONVERTER_TYPE__DESCRIPTION:
-				return getDescription();
-			case FacesConfigPackage.CONVERTER_TYPE__DISPLAY_NAME:
-				return getDisplayName();
-			case FacesConfigPackage.CONVERTER_TYPE__ICON:
-				return getIcon();
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_ID:
-				return getConverterId();
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_FOR_CLASS:
-				return getConverterForClass();
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_CLASS:
-				return getConverterClass();
-			case FacesConfigPackage.CONVERTER_TYPE__ATTRIBUTE:
-				return getAttribute();
-			case FacesConfigPackage.CONVERTER_TYPE__PROPERTY:
-				return getProperty();
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_EXTENSION:
-				return getConverterExtension();
-			case FacesConfigPackage.CONVERTER_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.CONVERTER_TYPE__DESCRIPTION:
-				getDescription().clear();
-				getDescription().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.CONVERTER_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				getDisplayName().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.CONVERTER_TYPE__ICON:
-				getIcon().clear();
-				getIcon().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_ID:
-				setConverterId((ConverterIdType)newValue);
-				return;
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_FOR_CLASS:
-				setConverterForClass((ConverterForClassType)newValue);
-				return;
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_CLASS:
-				setConverterClass((ConverterClassType)newValue);
-				return;
-			case FacesConfigPackage.CONVERTER_TYPE__ATTRIBUTE:
-				getAttribute().clear();
-				getAttribute().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.CONVERTER_TYPE__PROPERTY:
-				getProperty().clear();
-				getProperty().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_EXTENSION:
-				getConverterExtension().clear();
-				getConverterExtension().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.CONVERTER_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.CONVERTER_TYPE__DESCRIPTION:
-				getDescription().clear();
-				return;
-			case FacesConfigPackage.CONVERTER_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				return;
-			case FacesConfigPackage.CONVERTER_TYPE__ICON:
-				getIcon().clear();
-				return;
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_ID:
-				setConverterId((ConverterIdType)null);
-				return;
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_FOR_CLASS:
-				setConverterForClass((ConverterForClassType)null);
-				return;
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_CLASS:
-				setConverterClass((ConverterClassType)null);
-				return;
-			case FacesConfigPackage.CONVERTER_TYPE__ATTRIBUTE:
-				getAttribute().clear();
-				return;
-			case FacesConfigPackage.CONVERTER_TYPE__PROPERTY:
-				getProperty().clear();
-				return;
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_EXTENSION:
-				getConverterExtension().clear();
-				return;
-			case FacesConfigPackage.CONVERTER_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.CONVERTER_TYPE__DESCRIPTION:
-				return description != null && !description.isEmpty();
-			case FacesConfigPackage.CONVERTER_TYPE__DISPLAY_NAME:
-				return displayName != null && !displayName.isEmpty();
-			case FacesConfigPackage.CONVERTER_TYPE__ICON:
-				return icon != null && !icon.isEmpty();
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_ID:
-				return converterId != null;
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_FOR_CLASS:
-				return converterForClass != null;
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_CLASS:
-				return converterClass != null;
-			case FacesConfigPackage.CONVERTER_TYPE__ATTRIBUTE:
-				return attribute != null && !attribute.isEmpty();
-			case FacesConfigPackage.CONVERTER_TYPE__PROPERTY:
-				return property != null && !property.isEmpty();
-			case FacesConfigPackage.CONVERTER_TYPE__CONVERTER_EXTENSION:
-				return converterExtension != null && !converterExtension.isEmpty();
-			case FacesConfigPackage.CONVERTER_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ConverterTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DefaultLocaleTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DefaultLocaleTypeImpl.java
deleted file mode 100644
index 78cb7b6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DefaultLocaleTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.DefaultLocaleType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Default Locale Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultLocaleTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultLocaleTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class DefaultLocaleTypeImpl extends EObjectImpl implements DefaultLocaleType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected DefaultLocaleTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.DEFAULT_LOCALE_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.DEFAULT_LOCALE_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.DEFAULT_LOCALE_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.DEFAULT_LOCALE_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.DEFAULT_LOCALE_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.DEFAULT_LOCALE_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.DEFAULT_LOCALE_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.DEFAULT_LOCALE_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.DEFAULT_LOCALE_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.DEFAULT_LOCALE_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.DEFAULT_LOCALE_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //DefaultLocaleTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DefaultRenderKitIdTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DefaultRenderKitIdTypeImpl.java
deleted file mode 100644
index 7091636..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DefaultRenderKitIdTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.DefaultRenderKitIdType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Default Render Kit Id Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultRenderKitIdTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultRenderKitIdTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class DefaultRenderKitIdTypeImpl extends EObjectImpl implements DefaultRenderKitIdType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected DefaultRenderKitIdTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.DEFAULT_RENDER_KIT_ID_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.DEFAULT_RENDER_KIT_ID_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.DEFAULT_RENDER_KIT_ID_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.DEFAULT_RENDER_KIT_ID_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.DEFAULT_RENDER_KIT_ID_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.DEFAULT_RENDER_KIT_ID_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.DEFAULT_RENDER_KIT_ID_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.DEFAULT_RENDER_KIT_ID_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.DEFAULT_RENDER_KIT_ID_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.DEFAULT_RENDER_KIT_ID_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.DEFAULT_RENDER_KIT_ID_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //DefaultRenderKitIdTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DefaultValidatorsTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DefaultValidatorsTypeImpl.java
deleted file mode 100644
index dc222bf..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DefaultValidatorsTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.DefaultValidatorsType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ValidatorIdType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Default Validators Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultValidatorsTypeImpl#getValidatorId <em>Validator Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultValidatorsTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class DefaultValidatorsTypeImpl extends EObjectImpl implements DefaultValidatorsType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The cached value of the '{@link #getValidatorId() <em>Validator Id</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getValidatorId()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList validatorId;
-
-	/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected DefaultValidatorsTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.DEFAULT_VALIDATORS_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getValidatorId() {
-		if (validatorId == null) {
-			validatorId = new EObjectContainmentEList(ValidatorIdType.class, this, FacesConfigPackage.DEFAULT_VALIDATORS_TYPE__VALIDATOR_ID);
-		}
-		return validatorId;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.DEFAULT_VALIDATORS_TYPE__ID, oldId, id));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.DEFAULT_VALIDATORS_TYPE__VALIDATOR_ID:
-				return ((InternalEList)getValidatorId()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.DEFAULT_VALIDATORS_TYPE__VALIDATOR_ID:
-				return getValidatorId();
-			case FacesConfigPackage.DEFAULT_VALIDATORS_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.DEFAULT_VALIDATORS_TYPE__VALIDATOR_ID:
-				getValidatorId().clear();
-				getValidatorId().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.DEFAULT_VALIDATORS_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.DEFAULT_VALIDATORS_TYPE__VALIDATOR_ID:
-				getValidatorId().clear();
-				return;
-			case FacesConfigPackage.DEFAULT_VALIDATORS_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.DEFAULT_VALIDATORS_TYPE__VALIDATOR_ID:
-				return validatorId != null && !validatorId.isEmpty();
-			case FacesConfigPackage.DEFAULT_VALIDATORS_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //DefaultValidatorsTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DefaultValueTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DefaultValueTypeImpl.java
deleted file mode 100644
index c5da609..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DefaultValueTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.DefaultValueType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Default Value Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultValueTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DefaultValueTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class DefaultValueTypeImpl extends EObjectImpl implements DefaultValueType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected DefaultValueTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.DEFAULT_VALUE_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.DEFAULT_VALUE_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.DEFAULT_VALUE_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.DEFAULT_VALUE_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.DEFAULT_VALUE_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.DEFAULT_VALUE_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.DEFAULT_VALUE_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.DEFAULT_VALUE_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.DEFAULT_VALUE_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.DEFAULT_VALUE_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.DEFAULT_VALUE_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //DefaultValueTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DescriptionTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DescriptionTypeImpl.java
deleted file mode 100644
index 31368c7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DescriptionTypeImpl.java
+++ /dev/null
@@ -1,279 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.DescriptionType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Description Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DescriptionTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DescriptionTypeImpl#getLang <em>Lang</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DescriptionTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class DescriptionTypeImpl extends EObjectImpl implements DescriptionType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getLang() <em>Lang</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getLang()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String LANG_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getLang() <em>Lang</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getLang()
-	 * @generated
-	 * @ordered
-	 */
-	protected String lang = LANG_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected DescriptionTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.DESCRIPTION_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.DESCRIPTION_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getLang() {
-		return lang;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setLang(String newLang) {
-		String oldLang = lang;
-		lang = newLang;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.DESCRIPTION_TYPE__LANG, oldLang, lang));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.DESCRIPTION_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.DESCRIPTION_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.DESCRIPTION_TYPE__LANG:
-				return getLang();
-			case FacesConfigPackage.DESCRIPTION_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.DESCRIPTION_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.DESCRIPTION_TYPE__LANG:
-				setLang((String)newValue);
-				return;
-			case FacesConfigPackage.DESCRIPTION_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.DESCRIPTION_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.DESCRIPTION_TYPE__LANG:
-				setLang(LANG_EDEFAULT);
-				return;
-			case FacesConfigPackage.DESCRIPTION_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.DESCRIPTION_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.DESCRIPTION_TYPE__LANG:
-				return LANG_EDEFAULT == null ? lang != null : !LANG_EDEFAULT.equals(lang);
-			case FacesConfigPackage.DESCRIPTION_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", lang: ");//$NON-NLS-1$
-		result.append(lang);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //DescriptionTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DisplayNameTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DisplayNameTypeImpl.java
deleted file mode 100644
index 85b8ea0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DisplayNameTypeImpl.java
+++ /dev/null
@@ -1,279 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Display Name Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DisplayNameTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DisplayNameTypeImpl#getLang <em>Lang</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DisplayNameTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class DisplayNameTypeImpl extends EObjectImpl implements DisplayNameType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getLang() <em>Lang</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getLang()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String LANG_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getLang() <em>Lang</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getLang()
-	 * @generated
-	 * @ordered
-	 */
-	protected String lang = LANG_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected DisplayNameTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.DISPLAY_NAME_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.DISPLAY_NAME_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getLang() {
-		return lang;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setLang(String newLang) {
-		String oldLang = lang;
-		lang = newLang;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.DISPLAY_NAME_TYPE__LANG, oldLang, lang));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.DISPLAY_NAME_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.DISPLAY_NAME_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.DISPLAY_NAME_TYPE__LANG:
-				return getLang();
-			case FacesConfigPackage.DISPLAY_NAME_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.DISPLAY_NAME_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.DISPLAY_NAME_TYPE__LANG:
-				setLang((String)newValue);
-				return;
-			case FacesConfigPackage.DISPLAY_NAME_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.DISPLAY_NAME_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.DISPLAY_NAME_TYPE__LANG:
-				setLang(LANG_EDEFAULT);
-				return;
-			case FacesConfigPackage.DISPLAY_NAME_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.DISPLAY_NAME_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.DISPLAY_NAME_TYPE__LANG:
-				return LANG_EDEFAULT == null ? lang != null : !LANG_EDEFAULT.equals(lang);
-			case FacesConfigPackage.DISPLAY_NAME_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", lang: ");//$NON-NLS-1$
-		result.append(lang);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //DisplayNameTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DocumentRootImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DocumentRootImpl.java
deleted file mode 100644
index 43083da..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DocumentRootImpl.java
+++ /dev/null
@@ -1,4674 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.common.util.EMap;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.EcorePackage;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.EObjectImpl;
-import org.eclipse.emf.ecore.impl.EStringToStringMapEntryImpl;
-import org.eclipse.emf.ecore.util.BasicFeatureMap;
-import org.eclipse.emf.ecore.util.EcoreEMap;
-import org.eclipse.emf.ecore.util.FeatureMap;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.*;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Document Root</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getMixed <em>Mixed</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getXMLNSPrefixMap <em>XMLNS Prefix Map</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getXSISchemaLocation <em>XSI Schema Location</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getAbsoluteOrdering <em>Absolute Ordering</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getActionListener <em>Action Listener</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getApplication <em>Application</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getApplicationFactory <em>Application Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getAttribute <em>Attribute</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getAttributeClass <em>Attribute Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getAttributeExtension <em>Attribute Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getAttributeName <em>Attribute Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getBehavior <em>Behavior</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getBehaviorClass <em>Behavior Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getBehaviorId <em>Behavior Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getBehaviorExtension <em>Behavior Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getComponent <em>Component</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getComponentClass <em>Component Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getComponentExtension <em>Component Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getComponentFamily <em>Component Family</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getComponentType <em>Component Type</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getConverter <em>Converter</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getConverterClass <em>Converter Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getConverterForClass <em>Converter For Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getConverterId <em>Converter Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getDefaultLocale <em>Default Locale</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getDefaultRenderKitId <em>Default Render Kit Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getDefaultValidators <em>Default Validators</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getDefaultValue <em>Default Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getExceptionHandlerFactory <em>Exception Handler Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getExternalContextFactory <em>External Context Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getFacesConfig <em>Faces Config</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getFacesContextFactory <em>Faces Context Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getFacet <em>Facet</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getFacetExtension <em>Facet Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getFacetName <em>Facet Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getFactory <em>Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getFromAction <em>From Action</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getFromOutcome <em>From Outcome</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getFromViewId <em>From View Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getIf <em>If</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getKey <em>Key</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getKeyClass <em>Key Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getLargeIcon <em>Large Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getLifecycle <em>Lifecycle</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getLifecycleFactory <em>Lifecycle Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getListEntries <em>List Entries</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getLocaleConfig <em>Locale Config</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getManagedBean <em>Managed Bean</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getManagedBeanClass <em>Managed Bean Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getManagedBeanName <em>Managed Bean Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getManagedBeanScope <em>Managed Bean Scope</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getManagedProperty <em>Managed Property</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getMapEntries <em>Map Entries</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getMapEntry <em>Map Entry</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getMessageBundle <em>Message Bundle</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getNavigationCase <em>Navigation Case</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getNavigationHandler <em>Navigation Handler</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getNavigationRule <em>Navigation Rule</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getNullValue <em>Null Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getOrdering <em>Ordering</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getOrderingOrdering <em>Ordering Ordering</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getOthers <em>Others</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getPartialViewContextFactory <em>Partial View Context Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getPhaseListener <em>Phase Listener</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getProperty <em>Property</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getPropertyClass <em>Property Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getPropertyExtension <em>Property Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getPropertyName <em>Property Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getPropertyResolver <em>Property Resolver</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getRedirect <em>Redirect</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getRedirectViewParam <em>Redirect View Param</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getReferencedBean <em>Referenced Bean</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getReferencedBeanClass <em>Referenced Bean Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getReferencedBeanName <em>Referenced Bean Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getRenderer <em>Renderer</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getRendererClass <em>Renderer Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getRendererExtension <em>Renderer Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getRendererType <em>Renderer Type</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getRenderKit <em>Render Kit</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getRenderKitClass <em>Render Kit Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getRenderKitFactory <em>Render Kit Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getRenderKitId <em>Render Kit Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getResourceHandler <em>Resource Handler</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getSmallIcon <em>Small Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getSourceClass <em>Source Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getStateManager <em>State Manager</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getSuggestedValue <em>Suggested Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getSupportedLocale <em>Supported Locale</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getSystemEventClass <em>System Event Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getSystemEventListener <em>System Event Listener</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getSystemEventListenerClass <em>System Event Listener Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getTagHandlerDelegateFactory <em>Tag Handler Delegate Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getToViewId <em>To View Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getValidator <em>Validator</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getValidatorClass <em>Validator Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getValidatorId <em>Validator Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getValue <em>Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getValueClass <em>Value Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getVariableResolver <em>Variable Resolver</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getViewDeclarationLanguageFactory <em>View Declaration Language Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getViewHandler <em>View Handler</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DocumentRootImpl#getVisitContextFactory <em>Visit Context Factory</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class DocumentRootImpl extends EObjectImpl implements DocumentRoot {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getMixed() <em>Mixed</em>}' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getMixed()
-	 * @generated
-	 * @ordered
-	 */
-	protected FeatureMap mixed;
-
-    /**
-	 * The cached value of the '{@link #getXMLNSPrefixMap() <em>XMLNS Prefix Map</em>}' map.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getXMLNSPrefixMap()
-	 * @generated
-	 * @ordered
-	 */
-	protected EMap xMLNSPrefixMap;
-
-    /**
-	 * The cached value of the '{@link #getXSISchemaLocation() <em>XSI Schema Location</em>}' map.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getXSISchemaLocation()
-	 * @generated
-	 * @ordered
-	 */
-	protected EMap xSISchemaLocation;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected DocumentRootImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.DOCUMENT_ROOT;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FeatureMap getMixed() {
-		if (mixed == null) {
-			mixed = new BasicFeatureMap(this, FacesConfigPackage.DOCUMENT_ROOT__MIXED);
-		}
-		return mixed;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EMap getXMLNSPrefixMap() {
-		if (xMLNSPrefixMap == null) {
-			xMLNSPrefixMap = new EcoreEMap(EcorePackage.Literals.ESTRING_TO_STRING_MAP_ENTRY, EStringToStringMapEntryImpl.class, this, FacesConfigPackage.DOCUMENT_ROOT__XMLNS_PREFIX_MAP);
-		}
-		return xMLNSPrefixMap;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EMap getXSISchemaLocation() {
-		if (xSISchemaLocation == null) {
-			xSISchemaLocation = new EcoreEMap(EcorePackage.Literals.ESTRING_TO_STRING_MAP_ENTRY, EStringToStringMapEntryImpl.class, this, FacesConfigPackage.DOCUMENT_ROOT__XSI_SCHEMA_LOCATION);
-		}
-		return xSISchemaLocation;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public AbsoluteOrderingType getAbsoluteOrdering() {
-		return (AbsoluteOrderingType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__ABSOLUTE_ORDERING, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newAbsoluteOrdering 
-	 * @param msgs 
-	 * @return  NotficationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetAbsoluteOrdering(AbsoluteOrderingType newAbsoluteOrdering, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__ABSOLUTE_ORDERING, newAbsoluteOrdering, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setAbsoluteOrdering(AbsoluteOrderingType newAbsoluteOrdering) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__ABSOLUTE_ORDERING, newAbsoluteOrdering);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ActionListenerType getActionListener() {
-		return (ActionListenerType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__ACTION_LISTENER, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newActionListener 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetActionListener(ActionListenerType newActionListener, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__ACTION_LISTENER, newActionListener, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setActionListener(ActionListenerType newActionListener) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__ACTION_LISTENER, newActionListener);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ApplicationType getApplication() {
-		return (ApplicationType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__APPLICATION, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newApplication 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetApplication(ApplicationType newApplication, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__APPLICATION, newApplication, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setApplication(ApplicationType newApplication) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__APPLICATION, newApplication);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ApplicationFactoryType getApplicationFactory() {
-		return (ApplicationFactoryType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__APPLICATION_FACTORY, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newApplicationFactory 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetApplicationFactory(ApplicationFactoryType newApplicationFactory, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__APPLICATION_FACTORY, newApplicationFactory, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setApplicationFactory(ApplicationFactoryType newApplicationFactory) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__APPLICATION_FACTORY, newApplicationFactory);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public AttributeType getAttribute() {
-		return (AttributeType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__ATTRIBUTE, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newAttribute 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetAttribute(AttributeType newAttribute, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__ATTRIBUTE, newAttribute, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setAttribute(AttributeType newAttribute) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__ATTRIBUTE, newAttribute);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public AttributeClassType getAttributeClass() {
-		return (AttributeClassType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__ATTRIBUTE_CLASS, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newAttributeClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetAttributeClass(AttributeClassType newAttributeClass, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__ATTRIBUTE_CLASS, newAttributeClass, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setAttributeClass(AttributeClassType newAttributeClass) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__ATTRIBUTE_CLASS, newAttributeClass);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public AttributeExtensionType getAttributeExtension() {
-		return (AttributeExtensionType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__ATTRIBUTE_EXTENSION, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newAttributeExtension 
-     * @param msgs 
-     * @return the notification chiain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetAttributeExtension(AttributeExtensionType newAttributeExtension, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__ATTRIBUTE_EXTENSION, newAttributeExtension, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setAttributeExtension(AttributeExtensionType newAttributeExtension) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__ATTRIBUTE_EXTENSION, newAttributeExtension);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public AttributeNameType getAttributeName() {
-		return (AttributeNameType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__ATTRIBUTE_NAME, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newAttributeName 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetAttributeName(AttributeNameType newAttributeName, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__ATTRIBUTE_NAME, newAttributeName, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setAttributeName(AttributeNameType newAttributeName) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__ATTRIBUTE_NAME, newAttributeName);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public BehaviorType getBehavior() {
-		return (BehaviorType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__BEHAVIOR, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newBehavior 
-	 * @param msgs NotificationChain
-	 * @return 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetBehavior(BehaviorType newBehavior, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__BEHAVIOR, newBehavior, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setBehavior(BehaviorType newBehavior) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__BEHAVIOR, newBehavior);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public BehaviorClassType getBehaviorClass() {
-		return (BehaviorClassType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__BEHAVIOR_CLASS, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newBehaviorClass 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetBehaviorClass(BehaviorClassType newBehaviorClass, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__BEHAVIOR_CLASS, newBehaviorClass, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setBehaviorClass(BehaviorClassType newBehaviorClass) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__BEHAVIOR_CLASS, newBehaviorClass);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public BehaviorIdType getBehaviorId() {
-		return (BehaviorIdType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__BEHAVIOR_ID, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newBehaviorId 
-	 * @param msgs 
-	 * @return NotificationChain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetBehaviorId(BehaviorIdType newBehaviorId, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__BEHAVIOR_ID, newBehaviorId, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setBehaviorId(BehaviorIdType newBehaviorId) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__BEHAVIOR_ID, newBehaviorId);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public BehaviorExtensionType getBehaviorExtension() {
-		return (BehaviorExtensionType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__BEHAVIOR_EXTENSION, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newBehaviorExtension 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetBehaviorExtension(BehaviorExtensionType newBehaviorExtension, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__BEHAVIOR_EXTENSION, newBehaviorExtension, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setBehaviorExtension(BehaviorExtensionType newBehaviorExtension) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__BEHAVIOR_EXTENSION, newBehaviorExtension);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ComponentType getComponent() {
-		return (ComponentType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newComponent 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetComponent(ComponentType newComponent, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT, newComponent, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setComponent(ComponentType newComponent) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT, newComponent);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ComponentClassType getComponentClass() {
-		return (ComponentClassType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT_CLASS, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newComponentClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetComponentClass(ComponentClassType newComponentClass, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT_CLASS, newComponentClass, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setComponentClass(ComponentClassType newComponentClass) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT_CLASS, newComponentClass);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ComponentExtensionType getComponentExtension() {
-		return (ComponentExtensionType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT_EXTENSION, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newComponentExtension 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetComponentExtension(ComponentExtensionType newComponentExtension, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT_EXTENSION, newComponentExtension, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setComponentExtension(ComponentExtensionType newComponentExtension) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT_EXTENSION, newComponentExtension);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ComponentFamilyType getComponentFamily() {
-		return (ComponentFamilyType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT_FAMILY, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newComponentFamily 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetComponentFamily(ComponentFamilyType newComponentFamily, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT_FAMILY, newComponentFamily, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setComponentFamily(ComponentFamilyType newComponentFamily) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT_FAMILY, newComponentFamily);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ComponentTypeType getComponentType() {
-		return (ComponentTypeType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT_TYPE, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newComponentType 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetComponentType(ComponentTypeType newComponentType, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT_TYPE, newComponentType, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setComponentType(ComponentTypeType newComponentType) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__COMPONENT_TYPE, newComponentType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConverterType getConverter() {
-		return (ConverterType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__CONVERTER, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newConverter 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetConverter(ConverterType newConverter, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__CONVERTER, newConverter, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setConverter(ConverterType newConverter) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__CONVERTER, newConverter);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConverterClassType getConverterClass() {
-		return (ConverterClassType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__CONVERTER_CLASS, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newConverterClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetConverterClass(ConverterClassType newConverterClass, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__CONVERTER_CLASS, newConverterClass, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setConverterClass(ConverterClassType newConverterClass) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__CONVERTER_CLASS, newConverterClass);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConverterForClassType getConverterForClass() {
-		return (ConverterForClassType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__CONVERTER_FOR_CLASS, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newConverterForClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetConverterForClass(ConverterForClassType newConverterForClass, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__CONVERTER_FOR_CLASS, newConverterForClass, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setConverterForClass(ConverterForClassType newConverterForClass) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__CONVERTER_FOR_CLASS, newConverterForClass);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConverterIdType getConverterId() {
-		return (ConverterIdType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__CONVERTER_ID, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newConverterId 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetConverterId(ConverterIdType newConverterId, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__CONVERTER_ID, newConverterId, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setConverterId(ConverterIdType newConverterId) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__CONVERTER_ID, newConverterId);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DefaultLocaleType getDefaultLocale() {
-		return (DefaultLocaleType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__DEFAULT_LOCALE, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newDefaultLocale 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetDefaultLocale(DefaultLocaleType newDefaultLocale, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__DEFAULT_LOCALE, newDefaultLocale, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setDefaultLocale(DefaultLocaleType newDefaultLocale) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__DEFAULT_LOCALE, newDefaultLocale);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DefaultRenderKitIdType getDefaultRenderKitId() {
-		return (DefaultRenderKitIdType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__DEFAULT_RENDER_KIT_ID, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newDefaultRenderKitId 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetDefaultRenderKitId(DefaultRenderKitIdType newDefaultRenderKitId, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__DEFAULT_RENDER_KIT_ID, newDefaultRenderKitId, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setDefaultRenderKitId(DefaultRenderKitIdType newDefaultRenderKitId) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__DEFAULT_RENDER_KIT_ID, newDefaultRenderKitId);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DefaultValidatorsType getDefaultValidators() {
-		return (DefaultValidatorsType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__DEFAULT_VALIDATORS, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newDefaultValidators 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetDefaultValidators(DefaultValidatorsType newDefaultValidators, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__DEFAULT_VALIDATORS, newDefaultValidators, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setDefaultValidators(DefaultValidatorsType newDefaultValidators) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__DEFAULT_VALIDATORS, newDefaultValidators);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DefaultValueType getDefaultValue() {
-		return (DefaultValueType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__DEFAULT_VALUE, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newDefaultValue 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetDefaultValue(DefaultValueType newDefaultValue, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__DEFAULT_VALUE, newDefaultValue, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setDefaultValue(DefaultValueType newDefaultValue) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__DEFAULT_VALUE, newDefaultValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DescriptionType getDescription() {
-		return (DescriptionType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__DESCRIPTION, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newDescription 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetDescription(DescriptionType newDescription, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__DESCRIPTION, newDescription, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setDescription(DescriptionType newDescription) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__DESCRIPTION, newDescription);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DisplayNameType getDisplayName() {
-		return (DisplayNameType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__DISPLAY_NAME, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newDisplayName 
-     * @param msgs 
-     * @return the notification 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetDisplayName(DisplayNameType newDisplayName, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__DISPLAY_NAME, newDisplayName, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setDisplayName(DisplayNameType newDisplayName) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__DISPLAY_NAME, newDisplayName);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ExceptionHandlerFactoryType getExceptionHandlerFactory() {
-		return (ExceptionHandlerFactoryType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__EXCEPTION_HANDLER_FACTORY, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newExceptionHandlerFactory 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetExceptionHandlerFactory(ExceptionHandlerFactoryType newExceptionHandlerFactory, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__EXCEPTION_HANDLER_FACTORY, newExceptionHandlerFactory, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setExceptionHandlerFactory(ExceptionHandlerFactoryType newExceptionHandlerFactory) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__EXCEPTION_HANDLER_FACTORY, newExceptionHandlerFactory);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ExternalContextFactoryType getExternalContextFactory() {
-		return (ExternalContextFactoryType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__EXTERNAL_CONTEXT_FACTORY, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newExternalContextFactory 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetExternalContextFactory(ExternalContextFactoryType newExternalContextFactory, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__EXTERNAL_CONTEXT_FACTORY, newExternalContextFactory, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setExternalContextFactory(ExternalContextFactoryType newExternalContextFactory) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__EXTERNAL_CONTEXT_FACTORY, newExternalContextFactory);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FacesConfigType getFacesConfig() {
-		return (FacesConfigType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACES_CONFIG, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newFacesConfig 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetFacesConfig(FacesConfigType newFacesConfig, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACES_CONFIG, newFacesConfig, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setFacesConfig(FacesConfigType newFacesConfig) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACES_CONFIG, newFacesConfig);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FacesContextFactoryType getFacesContextFactory() {
-		return (FacesContextFactoryType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACES_CONTEXT_FACTORY, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newFacesContextFactory 
-     * @param msgs 
-     * @return NotificationChain
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetFacesContextFactory(FacesContextFactoryType newFacesContextFactory, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACES_CONTEXT_FACTORY, newFacesContextFactory, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setFacesContextFactory(FacesContextFactoryType newFacesContextFactory) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACES_CONTEXT_FACTORY, newFacesContextFactory);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FacetType getFacet() {
-		return (FacetType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACET, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newFacet 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetFacet(FacetType newFacet, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACET, newFacet, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setFacet(FacetType newFacet) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACET, newFacet);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FacetExtensionType getFacetExtension() {
-		return (FacetExtensionType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACET_EXTENSION, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newFacetExtension 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetFacetExtension(FacetExtensionType newFacetExtension, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACET_EXTENSION, newFacetExtension, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setFacetExtension(FacetExtensionType newFacetExtension) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACET_EXTENSION, newFacetExtension);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FacetNameType getFacetName() {
-		return (FacetNameType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACET_NAME, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newFacetName 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetFacetName(FacetNameType newFacetName, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACET_NAME, newFacetName, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setFacetName(FacetNameType newFacetName) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACET_NAME, newFacetName);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FactoryType getFactory() {
-		return (FactoryType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACTORY, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newFactory 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetFactory(FactoryType newFactory, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACTORY, newFactory, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setFactory(FactoryType newFactory) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__FACTORY, newFactory);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FromActionType getFromAction() {
-		return (FromActionType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__FROM_ACTION, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newFromAction 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetFromAction(FromActionType newFromAction, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__FROM_ACTION, newFromAction, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setFromAction(FromActionType newFromAction) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__FROM_ACTION, newFromAction);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FromOutcomeType getFromOutcome() {
-		return (FromOutcomeType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__FROM_OUTCOME, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newFromOutcome 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetFromOutcome(FromOutcomeType newFromOutcome, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__FROM_OUTCOME, newFromOutcome, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setFromOutcome(FromOutcomeType newFromOutcome) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__FROM_OUTCOME, newFromOutcome);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FromViewIdType getFromViewId() {
-		return (FromViewIdType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__FROM_VIEW_ID, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newFromViewId 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetFromViewId(FromViewIdType newFromViewId, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__FROM_VIEW_ID, newFromViewId, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setFromViewId(FromViewIdType newFromViewId) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__FROM_VIEW_ID, newFromViewId);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public IconType getIcon() {
-		return (IconType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__ICON, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newIcon 
-     * @param msgs 
-     * @return the notification  chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetIcon(IconType newIcon, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__ICON, newIcon, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setIcon(IconType newIcon) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__ICON, newIcon);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public IfType getIf() {
-		return (IfType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__IF, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newIf 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetIf(IfType newIf, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__IF, newIf, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setIf(IfType newIf) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__IF, newIf);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public KeyType getKey() {
-		return (KeyType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__KEY, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newKey 
-     * @param msgs 
-     * @return the notification chiainn 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetKey(KeyType newKey, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__KEY, newKey, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setKey(KeyType newKey) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__KEY, newKey);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public KeyClassType getKeyClass() {
-		return (KeyClassType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__KEY_CLASS, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newKeyClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetKeyClass(KeyClassType newKeyClass, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__KEY_CLASS, newKeyClass, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setKeyClass(KeyClassType newKeyClass) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__KEY_CLASS, newKeyClass);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public LargeIconType getLargeIcon() {
-		return (LargeIconType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__LARGE_ICON, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newLargeIcon 
-     * @param msgs 
-     * @return the notification  chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetLargeIcon(LargeIconType newLargeIcon, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__LARGE_ICON, newLargeIcon, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setLargeIcon(LargeIconType newLargeIcon) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__LARGE_ICON, newLargeIcon);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public LifecycleType getLifecycle() {
-		return (LifecycleType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__LIFECYCLE, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newLifecycle 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetLifecycle(LifecycleType newLifecycle, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__LIFECYCLE, newLifecycle, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setLifecycle(LifecycleType newLifecycle) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__LIFECYCLE, newLifecycle);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public LifecycleFactoryType getLifecycleFactory() {
-		return (LifecycleFactoryType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__LIFECYCLE_FACTORY, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newLifecycleFactory 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetLifecycleFactory(LifecycleFactoryType newLifecycleFactory, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__LIFECYCLE_FACTORY, newLifecycleFactory, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setLifecycleFactory(LifecycleFactoryType newLifecycleFactory) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__LIFECYCLE_FACTORY, newLifecycleFactory);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ListEntriesType getListEntries() {
-		return (ListEntriesType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__LIST_ENTRIES, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newListEntries 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetListEntries(ListEntriesType newListEntries, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__LIST_ENTRIES, newListEntries, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setListEntries(ListEntriesType newListEntries) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__LIST_ENTRIES, newListEntries);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public LocaleConfigType getLocaleConfig() {
-		return (LocaleConfigType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__LOCALE_CONFIG, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newLocaleConfig 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetLocaleConfig(LocaleConfigType newLocaleConfig, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__LOCALE_CONFIG, newLocaleConfig, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setLocaleConfig(LocaleConfigType newLocaleConfig) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__LOCALE_CONFIG, newLocaleConfig);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ManagedBeanType getManagedBean() {
-		return (ManagedBeanType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_BEAN, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newManagedBean 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetManagedBean(ManagedBeanType newManagedBean, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_BEAN, newManagedBean, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setManagedBean(ManagedBeanType newManagedBean) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_BEAN, newManagedBean);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ManagedBeanClassType getManagedBeanClass() {
-		return (ManagedBeanClassType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_BEAN_CLASS, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newManagedBeanClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetManagedBeanClass(ManagedBeanClassType newManagedBeanClass, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_BEAN_CLASS, newManagedBeanClass, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setManagedBeanClass(ManagedBeanClassType newManagedBeanClass) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_BEAN_CLASS, newManagedBeanClass);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ManagedBeanNameType getManagedBeanName() {
-		return (ManagedBeanNameType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_BEAN_NAME, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newManagedBeanName 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetManagedBeanName(ManagedBeanNameType newManagedBeanName, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_BEAN_NAME, newManagedBeanName, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setManagedBeanName(ManagedBeanNameType newManagedBeanName) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_BEAN_NAME, newManagedBeanName);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ManagedBeanScopeType getManagedBeanScope() {
-		return (ManagedBeanScopeType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_BEAN_SCOPE, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newManagedBeanScope 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetManagedBeanScope(ManagedBeanScopeType newManagedBeanScope, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_BEAN_SCOPE, newManagedBeanScope, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setManagedBeanScope(ManagedBeanScopeType newManagedBeanScope) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_BEAN_SCOPE, newManagedBeanScope);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ManagedPropertyType getManagedProperty() {
-		return (ManagedPropertyType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_PROPERTY, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newManagedProperty 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetManagedProperty(ManagedPropertyType newManagedProperty, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_PROPERTY, newManagedProperty, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setManagedProperty(ManagedPropertyType newManagedProperty) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__MANAGED_PROPERTY, newManagedProperty);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public MapEntriesType getMapEntries() {
-		return (MapEntriesType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__MAP_ENTRIES, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newMapEntries 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetMapEntries(MapEntriesType newMapEntries, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__MAP_ENTRIES, newMapEntries, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setMapEntries(MapEntriesType newMapEntries) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__MAP_ENTRIES, newMapEntries);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public MapEntryType getMapEntry() {
-		return (MapEntryType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__MAP_ENTRY, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newMapEntry 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetMapEntry(MapEntryType newMapEntry, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__MAP_ENTRY, newMapEntry, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setMapEntry(MapEntryType newMapEntry) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__MAP_ENTRY, newMapEntry);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public MessageBundleType getMessageBundle() {
-		return (MessageBundleType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__MESSAGE_BUNDLE, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newMessageBundle 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetMessageBundle(MessageBundleType newMessageBundle, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__MESSAGE_BUNDLE, newMessageBundle, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setMessageBundle(MessageBundleType newMessageBundle) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__MESSAGE_BUNDLE, newMessageBundle);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NameType getName() {
-		return (NameType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__NAME, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newName 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetName(NameType newName, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__NAME, newName, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setName(NameType newName) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__NAME, newName);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NavigationCaseType getNavigationCase() {
-		return (NavigationCaseType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__NAVIGATION_CASE, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newNavigationCase 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetNavigationCase(NavigationCaseType newNavigationCase, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__NAVIGATION_CASE, newNavigationCase, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setNavigationCase(NavigationCaseType newNavigationCase) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__NAVIGATION_CASE, newNavigationCase);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NavigationHandlerType getNavigationHandler() {
-		return (NavigationHandlerType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__NAVIGATION_HANDLER, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newNavigationHandler 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetNavigationHandler(NavigationHandlerType newNavigationHandler, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__NAVIGATION_HANDLER, newNavigationHandler, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setNavigationHandler(NavigationHandlerType newNavigationHandler) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__NAVIGATION_HANDLER, newNavigationHandler);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NavigationRuleType getNavigationRule() {
-		return (NavigationRuleType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__NAVIGATION_RULE, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newNavigationRule 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetNavigationRule(NavigationRuleType newNavigationRule, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__NAVIGATION_RULE, newNavigationRule, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setNavigationRule(NavigationRuleType newNavigationRule) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__NAVIGATION_RULE, newNavigationRule);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NullValueType getNullValue() {
-		return (NullValueType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__NULL_VALUE, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newNullValue 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetNullValue(NullValueType newNullValue, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__NULL_VALUE, newNullValue, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setNullValue(NullValueType newNullValue) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__NULL_VALUE, newNullValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public OrderingType getOrdering() {
-		return (OrderingType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__ORDERING, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newOrdering 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetOrdering(OrderingType newOrdering, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__ORDERING, newOrdering, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setOrdering(OrderingType newOrdering) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__ORDERING, newOrdering);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public OrderingOrderingType getOrderingOrdering() {
-		return (OrderingOrderingType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__ORDERING_ORDERING, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newOrderingOrdering 
-	 * @param msgs 
-	 * @return NotificationChain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetOrderingOrdering(OrderingOrderingType newOrderingOrdering, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__ORDERING_ORDERING, newOrderingOrdering, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setOrderingOrdering(OrderingOrderingType newOrderingOrdering) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__ORDERING_ORDERING, newOrderingOrdering);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public OrderingOthersType getOthers() {
-		return (OrderingOthersType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__OTHERS, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newOthers 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetOthers(OrderingOthersType newOthers, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__OTHERS, newOthers, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setOthers(OrderingOthersType newOthers) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__OTHERS, newOthers);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PartialViewContextFactoryType getPartialViewContextFactory() {
-		return (PartialViewContextFactoryType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__PARTIAL_VIEW_CONTEXT_FACTORY, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newPartialViewContextFactory 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetPartialViewContextFactory(PartialViewContextFactoryType newPartialViewContextFactory, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__PARTIAL_VIEW_CONTEXT_FACTORY, newPartialViewContextFactory, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setPartialViewContextFactory(PartialViewContextFactoryType newPartialViewContextFactory) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__PARTIAL_VIEW_CONTEXT_FACTORY, newPartialViewContextFactory);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PhaseListenerType getPhaseListener() {
-		return (PhaseListenerType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__PHASE_LISTENER, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newPhaseListener 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetPhaseListener(PhaseListenerType newPhaseListener, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__PHASE_LISTENER, newPhaseListener, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setPhaseListener(PhaseListenerType newPhaseListener) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__PHASE_LISTENER, newPhaseListener);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PropertyType getProperty() {
-		return (PropertyType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newProperty 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetProperty(PropertyType newProperty, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY, newProperty, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setProperty(PropertyType newProperty) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY, newProperty);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PropertyClassType getPropertyClass() {
-		return (PropertyClassType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY_CLASS, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newPropertyClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetPropertyClass(PropertyClassType newPropertyClass, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY_CLASS, newPropertyClass, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setPropertyClass(PropertyClassType newPropertyClass) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY_CLASS, newPropertyClass);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PropertyExtensionType getPropertyExtension() {
-		return (PropertyExtensionType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY_EXTENSION, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newPropertyExtension 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetPropertyExtension(PropertyExtensionType newPropertyExtension, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY_EXTENSION, newPropertyExtension, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setPropertyExtension(PropertyExtensionType newPropertyExtension) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY_EXTENSION, newPropertyExtension);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PropertyNameType getPropertyName() {
-		return (PropertyNameType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY_NAME, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newPropertyName 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetPropertyName(PropertyNameType newPropertyName, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY_NAME, newPropertyName, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setPropertyName(PropertyNameType newPropertyName) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY_NAME, newPropertyName);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PropertyResolverType getPropertyResolver() {
-		return (PropertyResolverType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY_RESOLVER, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newPropertyResolver 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetPropertyResolver(PropertyResolverType newPropertyResolver, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY_RESOLVER, newPropertyResolver, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setPropertyResolver(PropertyResolverType newPropertyResolver) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__PROPERTY_RESOLVER, newPropertyResolver);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RedirectType getRedirect() {
-		return (RedirectType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__REDIRECT, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newRedirect 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetRedirect(RedirectType newRedirect, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__REDIRECT, newRedirect, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setRedirect(RedirectType newRedirect) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__REDIRECT, newRedirect);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RedirectViewParamType getRedirectViewParam() {
-		return (RedirectViewParamType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__REDIRECT_VIEW_PARAM, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newRedirectViewParam 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetRedirectViewParam(RedirectViewParamType newRedirectViewParam, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__REDIRECT_VIEW_PARAM, newRedirectViewParam, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setRedirectViewParam(RedirectViewParamType newRedirectViewParam) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__REDIRECT_VIEW_PARAM, newRedirectViewParam);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ReferencedBeanType getReferencedBean() {
-		return (ReferencedBeanType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__REFERENCED_BEAN, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newReferencedBean 
-     * @param msgs 
-     * @return the notification chai 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetReferencedBean(ReferencedBeanType newReferencedBean, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__REFERENCED_BEAN, newReferencedBean, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setReferencedBean(ReferencedBeanType newReferencedBean) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__REFERENCED_BEAN, newReferencedBean);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ReferencedBeanClassType getReferencedBeanClass() {
-		return (ReferencedBeanClassType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__REFERENCED_BEAN_CLASS, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newReferencedBeanClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetReferencedBeanClass(ReferencedBeanClassType newReferencedBeanClass, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__REFERENCED_BEAN_CLASS, newReferencedBeanClass, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setReferencedBeanClass(ReferencedBeanClassType newReferencedBeanClass) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__REFERENCED_BEAN_CLASS, newReferencedBeanClass);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ReferencedBeanNameType getReferencedBeanName() {
-		return (ReferencedBeanNameType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__REFERENCED_BEAN_NAME, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newReferencedBeanName 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetReferencedBeanName(ReferencedBeanNameType newReferencedBeanName, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__REFERENCED_BEAN_NAME, newReferencedBeanName, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setReferencedBeanName(ReferencedBeanNameType newReferencedBeanName) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__REFERENCED_BEAN_NAME, newReferencedBeanName);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RendererType getRenderer() {
-		return (RendererType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDERER, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newRenderer 
-     * @param msgs 
-     * @return the notification chain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetRenderer(RendererType newRenderer, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDERER, newRenderer, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setRenderer(RendererType newRenderer) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDERER, newRenderer);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RendererClassType getRendererClass() {
-		return (RendererClassType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDERER_CLASS, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newRendererClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetRendererClass(RendererClassType newRendererClass, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDERER_CLASS, newRendererClass, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setRendererClass(RendererClassType newRendererClass) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDERER_CLASS, newRendererClass);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RendererExtensionType getRendererExtension() {
-		return (RendererExtensionType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDERER_EXTENSION, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newRendererExtension 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetRendererExtension(RendererExtensionType newRendererExtension, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDERER_EXTENSION, newRendererExtension, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setRendererExtension(RendererExtensionType newRendererExtension) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDERER_EXTENSION, newRendererExtension);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RendererTypeType getRendererType() {
-		return (RendererTypeType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDERER_TYPE, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newRendererType 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetRendererType(RendererTypeType newRendererType, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDERER_TYPE, newRendererType, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setRendererType(RendererTypeType newRendererType) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDERER_TYPE, newRendererType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RenderKitType getRenderKit() {
-		return (RenderKitType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDER_KIT, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newRenderKit 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetRenderKit(RenderKitType newRenderKit, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDER_KIT, newRenderKit, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setRenderKit(RenderKitType newRenderKit) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDER_KIT, newRenderKit);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RenderKitClassType getRenderKitClass() {
-		return (RenderKitClassType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDER_KIT_CLASS, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newRenderKitClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetRenderKitClass(RenderKitClassType newRenderKitClass, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDER_KIT_CLASS, newRenderKitClass, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setRenderKitClass(RenderKitClassType newRenderKitClass) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDER_KIT_CLASS, newRenderKitClass);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RenderKitFactoryType getRenderKitFactory() {
-		return (RenderKitFactoryType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDER_KIT_FACTORY, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newRenderKitFactory 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetRenderKitFactory(RenderKitFactoryType newRenderKitFactory, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDER_KIT_FACTORY, newRenderKitFactory, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setRenderKitFactory(RenderKitFactoryType newRenderKitFactory) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDER_KIT_FACTORY, newRenderKitFactory);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RenderKitIdType getRenderKitId() {
-		return (RenderKitIdType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDER_KIT_ID, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newRenderKitId 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetRenderKitId(RenderKitIdType newRenderKitId, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDER_KIT_ID, newRenderKitId, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setRenderKitId(RenderKitIdType newRenderKitId) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__RENDER_KIT_ID, newRenderKitId);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceHandlerType getResourceHandler() {
-		return (ResourceHandlerType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__RESOURCE_HANDLER, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newResourceHandler 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetResourceHandler(ResourceHandlerType newResourceHandler, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__RESOURCE_HANDLER, newResourceHandler, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setResourceHandler(ResourceHandlerType newResourceHandler) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__RESOURCE_HANDLER, newResourceHandler);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SmallIconType getSmallIcon() {
-		return (SmallIconType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__SMALL_ICON, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newSmallIcon 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetSmallIcon(SmallIconType newSmallIcon, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__SMALL_ICON, newSmallIcon, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setSmallIcon(SmallIconType newSmallIcon) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__SMALL_ICON, newSmallIcon);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SourceClassType getSourceClass() {
-		return (SourceClassType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__SOURCE_CLASS, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newSourceClass 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetSourceClass(SourceClassType newSourceClass, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__SOURCE_CLASS, newSourceClass, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setSourceClass(SourceClassType newSourceClass) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__SOURCE_CLASS, newSourceClass);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public StateManagerType getStateManager() {
-		return (StateManagerType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__STATE_MANAGER, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newStateManager 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetStateManager(StateManagerType newStateManager, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__STATE_MANAGER, newStateManager, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setStateManager(StateManagerType newStateManager) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__STATE_MANAGER, newStateManager);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SuggestedValueType getSuggestedValue() {
-		return (SuggestedValueType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__SUGGESTED_VALUE, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newSuggestedValue 
-     * @param msgs 
-     * @return the notification chain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetSuggestedValue(SuggestedValueType newSuggestedValue, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__SUGGESTED_VALUE, newSuggestedValue, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setSuggestedValue(SuggestedValueType newSuggestedValue) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__SUGGESTED_VALUE, newSuggestedValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SupportedLocaleType getSupportedLocale() {
-		return (SupportedLocaleType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__SUPPORTED_LOCALE, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newSupportedLocale 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetSupportedLocale(SupportedLocaleType newSupportedLocale, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__SUPPORTED_LOCALE, newSupportedLocale, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setSupportedLocale(SupportedLocaleType newSupportedLocale) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__SUPPORTED_LOCALE, newSupportedLocale);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SystemEventClassType getSystemEventClass() {
-		return (SystemEventClassType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__SYSTEM_EVENT_CLASS, true);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * @param newSystemEventClass 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetSystemEventClass(SystemEventClassType newSystemEventClass, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__SYSTEM_EVENT_CLASS, newSystemEventClass, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setSystemEventClass(SystemEventClassType newSystemEventClass) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__SYSTEM_EVENT_CLASS, newSystemEventClass);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SystemEventListenerType getSystemEventListener() {
-		return (SystemEventListenerType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newSystemEventListener 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetSystemEventListener(SystemEventListenerType newSystemEventListener, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER, newSystemEventListener, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setSystemEventListener(SystemEventListenerType newSystemEventListener) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER, newSystemEventListener);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SystemEventListenerClassType getSystemEventListenerClass() {
-		return (SystemEventListenerClassType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER_CLASS, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newSystemEventListenerClass 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetSystemEventListenerClass(SystemEventListenerClassType newSystemEventListenerClass, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER_CLASS, newSystemEventListenerClass, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setSystemEventListenerClass(SystemEventListenerClassType newSystemEventListenerClass) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER_CLASS, newSystemEventListenerClass);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public TagHandlerDelegateFactoryType getTagHandlerDelegateFactory() {
-		return (TagHandlerDelegateFactoryType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__TAG_HANDLER_DELEGATE_FACTORY, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newTagHandlerDelegateFactory 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetTagHandlerDelegateFactory(TagHandlerDelegateFactoryType newTagHandlerDelegateFactory, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__TAG_HANDLER_DELEGATE_FACTORY, newTagHandlerDelegateFactory, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTagHandlerDelegateFactory(TagHandlerDelegateFactoryType newTagHandlerDelegateFactory) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__TAG_HANDLER_DELEGATE_FACTORY, newTagHandlerDelegateFactory);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ToViewIdType getToViewId() {
-		return (ToViewIdType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__TO_VIEW_ID, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newToViewId 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetToViewId(ToViewIdType newToViewId, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__TO_VIEW_ID, newToViewId, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setToViewId(ToViewIdType newToViewId) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__TO_VIEW_ID, newToViewId);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValidatorType getValidator() {
-		return (ValidatorType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALIDATOR, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newValidator 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetValidator(ValidatorType newValidator, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALIDATOR, newValidator, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setValidator(ValidatorType newValidator) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALIDATOR, newValidator);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValidatorClassType getValidatorClass() {
-		return (ValidatorClassType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALIDATOR_CLASS, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newValidatorClass 
-     * @param msgs 
-     * @return NotificationChain
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetValidatorClass(ValidatorClassType newValidatorClass, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALIDATOR_CLASS, newValidatorClass, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setValidatorClass(ValidatorClassType newValidatorClass) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALIDATOR_CLASS, newValidatorClass);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValidatorIdType getValidatorId() {
-		return (ValidatorIdType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALIDATOR_ID, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newValidatorId 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetValidatorId(ValidatorIdType newValidatorId, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALIDATOR_ID, newValidatorId, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setValidatorId(ValidatorIdType newValidatorId) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALIDATOR_ID, newValidatorId);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValueType getValue() {
-		return (ValueType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALUE, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newValue 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetValue(ValueType newValue, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALUE, newValue, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setValue(ValueType newValue) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALUE, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValueClassType getValueClass() {
-		return (ValueClassType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALUE_CLASS, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newValueClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetValueClass(ValueClassType newValueClass, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALUE_CLASS, newValueClass, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setValueClass(ValueClassType newValueClass) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__VALUE_CLASS, newValueClass);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public VariableResolverType getVariableResolver() {
-		return (VariableResolverType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__VARIABLE_RESOLVER, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newVariableResolver 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetVariableResolver(VariableResolverType newVariableResolver, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__VARIABLE_RESOLVER, newVariableResolver, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setVariableResolver(VariableResolverType newVariableResolver) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__VARIABLE_RESOLVER, newVariableResolver);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ViewDeclarationLanguageFactoryType getViewDeclarationLanguageFactory() {
-		return (ViewDeclarationLanguageFactoryType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__VIEW_DECLARATION_LANGUAGE_FACTORY, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newViewDeclarationLanguageFactory 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetViewDeclarationLanguageFactory(ViewDeclarationLanguageFactoryType newViewDeclarationLanguageFactory, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__VIEW_DECLARATION_LANGUAGE_FACTORY, newViewDeclarationLanguageFactory, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setViewDeclarationLanguageFactory(ViewDeclarationLanguageFactoryType newViewDeclarationLanguageFactory) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__VIEW_DECLARATION_LANGUAGE_FACTORY, newViewDeclarationLanguageFactory);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ViewHandlerType getViewHandler() {
-		return (ViewHandlerType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__VIEW_HANDLER, true);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newViewHandler 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetViewHandler(ViewHandlerType newViewHandler, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__VIEW_HANDLER, newViewHandler, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setViewHandler(ViewHandlerType newViewHandler) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__VIEW_HANDLER, newViewHandler);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public VisitContextFactoryType getVisitContextFactory() {
-		return (VisitContextFactoryType)getMixed().get(FacesConfigPackage.Literals.DOCUMENT_ROOT__VISIT_CONTEXT_FACTORY, true);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newVisitContextFactory 
-	 * @param msgs 
-	 * @return NotificationChain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetVisitContextFactory(VisitContextFactoryType newVisitContextFactory, NotificationChain msgs) {
-		return ((FeatureMap.Internal)getMixed()).basicAdd(FacesConfigPackage.Literals.DOCUMENT_ROOT__VISIT_CONTEXT_FACTORY, newVisitContextFactory, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setVisitContextFactory(VisitContextFactoryType newVisitContextFactory) {
-		((FeatureMap.Internal)getMixed()).set(FacesConfigPackage.Literals.DOCUMENT_ROOT__VISIT_CONTEXT_FACTORY, newVisitContextFactory);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.DOCUMENT_ROOT__MIXED:
-				return ((InternalEList)getMixed()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__XMLNS_PREFIX_MAP:
-				return ((InternalEList)getXMLNSPrefixMap()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__XSI_SCHEMA_LOCATION:
-				return ((InternalEList)getXSISchemaLocation()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__ABSOLUTE_ORDERING:
-				return basicSetAbsoluteOrdering(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__ACTION_LISTENER:
-				return basicSetActionListener(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__APPLICATION:
-				return basicSetApplication(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__APPLICATION_FACTORY:
-				return basicSetApplicationFactory(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE:
-				return basicSetAttribute(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE_CLASS:
-				return basicSetAttributeClass(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE_EXTENSION:
-				return basicSetAttributeExtension(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE_NAME:
-				return basicSetAttributeName(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR:
-				return basicSetBehavior(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR_CLASS:
-				return basicSetBehaviorClass(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR_ID:
-				return basicSetBehaviorId(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR_EXTENSION:
-				return basicSetBehaviorExtension(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT:
-				return basicSetComponent(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_CLASS:
-				return basicSetComponentClass(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_EXTENSION:
-				return basicSetComponentExtension(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_FAMILY:
-				return basicSetComponentFamily(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_TYPE:
-				return basicSetComponentType(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER:
-				return basicSetConverter(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER_CLASS:
-				return basicSetConverterClass(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER_FOR_CLASS:
-				return basicSetConverterForClass(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER_ID:
-				return basicSetConverterId(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_LOCALE:
-				return basicSetDefaultLocale(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_RENDER_KIT_ID:
-				return basicSetDefaultRenderKitId(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_VALIDATORS:
-				return basicSetDefaultValidators(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_VALUE:
-				return basicSetDefaultValue(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__DESCRIPTION:
-				return basicSetDescription(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__DISPLAY_NAME:
-				return basicSetDisplayName(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__EXCEPTION_HANDLER_FACTORY:
-				return basicSetExceptionHandlerFactory(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__EXTERNAL_CONTEXT_FACTORY:
-				return basicSetExternalContextFactory(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__FACES_CONFIG:
-				return basicSetFacesConfig(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__FACES_CONTEXT_FACTORY:
-				return basicSetFacesContextFactory(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__FACET:
-				return basicSetFacet(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__FACET_EXTENSION:
-				return basicSetFacetExtension(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__FACET_NAME:
-				return basicSetFacetName(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__FACTORY:
-				return basicSetFactory(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__FROM_ACTION:
-				return basicSetFromAction(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__FROM_OUTCOME:
-				return basicSetFromOutcome(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__FROM_VIEW_ID:
-				return basicSetFromViewId(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__ICON:
-				return basicSetIcon(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__IF:
-				return basicSetIf(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__KEY:
-				return basicSetKey(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__KEY_CLASS:
-				return basicSetKeyClass(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__LARGE_ICON:
-				return basicSetLargeIcon(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__LIFECYCLE:
-				return basicSetLifecycle(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__LIFECYCLE_FACTORY:
-				return basicSetLifecycleFactory(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__LIST_ENTRIES:
-				return basicSetListEntries(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__LOCALE_CONFIG:
-				return basicSetLocaleConfig(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN:
-				return basicSetManagedBean(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN_CLASS:
-				return basicSetManagedBeanClass(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN_NAME:
-				return basicSetManagedBeanName(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN_SCOPE:
-				return basicSetManagedBeanScope(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_PROPERTY:
-				return basicSetManagedProperty(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__MAP_ENTRIES:
-				return basicSetMapEntries(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__MAP_ENTRY:
-				return basicSetMapEntry(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__MESSAGE_BUNDLE:
-				return basicSetMessageBundle(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__NAME:
-				return basicSetName(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__NAVIGATION_CASE:
-				return basicSetNavigationCase(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__NAVIGATION_HANDLER:
-				return basicSetNavigationHandler(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__NAVIGATION_RULE:
-				return basicSetNavigationRule(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__NULL_VALUE:
-				return basicSetNullValue(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__ORDERING:
-				return basicSetOrdering(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__ORDERING_ORDERING:
-				return basicSetOrderingOrdering(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__OTHERS:
-				return basicSetOthers(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__PARTIAL_VIEW_CONTEXT_FACTORY:
-				return basicSetPartialViewContextFactory(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__PHASE_LISTENER:
-				return basicSetPhaseListener(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY:
-				return basicSetProperty(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_CLASS:
-				return basicSetPropertyClass(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_EXTENSION:
-				return basicSetPropertyExtension(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_NAME:
-				return basicSetPropertyName(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_RESOLVER:
-				return basicSetPropertyResolver(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__REDIRECT:
-				return basicSetRedirect(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__REDIRECT_VIEW_PARAM:
-				return basicSetRedirectViewParam(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__REFERENCED_BEAN:
-				return basicSetReferencedBean(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__REFERENCED_BEAN_CLASS:
-				return basicSetReferencedBeanClass(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__REFERENCED_BEAN_NAME:
-				return basicSetReferencedBeanName(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER:
-				return basicSetRenderer(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER_CLASS:
-				return basicSetRendererClass(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER_EXTENSION:
-				return basicSetRendererExtension(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER_TYPE:
-				return basicSetRendererType(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT:
-				return basicSetRenderKit(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT_CLASS:
-				return basicSetRenderKitClass(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT_FACTORY:
-				return basicSetRenderKitFactory(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT_ID:
-				return basicSetRenderKitId(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__RESOURCE_HANDLER:
-				return basicSetResourceHandler(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__SMALL_ICON:
-				return basicSetSmallIcon(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__SOURCE_CLASS:
-				return basicSetSourceClass(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__STATE_MANAGER:
-				return basicSetStateManager(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__SUGGESTED_VALUE:
-				return basicSetSuggestedValue(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__SUPPORTED_LOCALE:
-				return basicSetSupportedLocale(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__SYSTEM_EVENT_CLASS:
-				return basicSetSystemEventClass(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER:
-				return basicSetSystemEventListener(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER_CLASS:
-				return basicSetSystemEventListenerClass(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__TAG_HANDLER_DELEGATE_FACTORY:
-				return basicSetTagHandlerDelegateFactory(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__TO_VIEW_ID:
-				return basicSetToViewId(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__VALIDATOR:
-				return basicSetValidator(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__VALIDATOR_CLASS:
-				return basicSetValidatorClass(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__VALIDATOR_ID:
-				return basicSetValidatorId(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__VALUE:
-				return basicSetValue(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__VALUE_CLASS:
-				return basicSetValueClass(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__VARIABLE_RESOLVER:
-				return basicSetVariableResolver(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__VIEW_DECLARATION_LANGUAGE_FACTORY:
-				return basicSetViewDeclarationLanguageFactory(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__VIEW_HANDLER:
-				return basicSetViewHandler(null, msgs);
-			case FacesConfigPackage.DOCUMENT_ROOT__VISIT_CONTEXT_FACTORY:
-				return basicSetVisitContextFactory(null, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.DOCUMENT_ROOT__MIXED:
-				if (coreType) return getMixed();
-				return ((FeatureMap.Internal)getMixed()).getWrapper();
-			case FacesConfigPackage.DOCUMENT_ROOT__XMLNS_PREFIX_MAP:
-				if (coreType) return getXMLNSPrefixMap();
-				    return getXMLNSPrefixMap().map();
-			case FacesConfigPackage.DOCUMENT_ROOT__XSI_SCHEMA_LOCATION:
-				if (coreType) return getXSISchemaLocation();
-				     return getXSISchemaLocation().map();
-			case FacesConfigPackage.DOCUMENT_ROOT__ABSOLUTE_ORDERING:
-				return getAbsoluteOrdering();
-			case FacesConfigPackage.DOCUMENT_ROOT__ACTION_LISTENER:
-				return getActionListener();
-			case FacesConfigPackage.DOCUMENT_ROOT__APPLICATION:
-				return getApplication();
-			case FacesConfigPackage.DOCUMENT_ROOT__APPLICATION_FACTORY:
-				return getApplicationFactory();
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE:
-				return getAttribute();
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE_CLASS:
-				return getAttributeClass();
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE_EXTENSION:
-				return getAttributeExtension();
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE_NAME:
-				return getAttributeName();
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR:
-				return getBehavior();
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR_CLASS:
-				return getBehaviorClass();
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR_ID:
-				return getBehaviorId();
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR_EXTENSION:
-				return getBehaviorExtension();
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT:
-				return getComponent();
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_CLASS:
-				return getComponentClass();
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_EXTENSION:
-				return getComponentExtension();
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_FAMILY:
-				return getComponentFamily();
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_TYPE:
-				return getComponentType();
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER:
-				return getConverter();
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER_CLASS:
-				return getConverterClass();
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER_FOR_CLASS:
-				return getConverterForClass();
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER_ID:
-				return getConverterId();
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_LOCALE:
-				return getDefaultLocale();
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_RENDER_KIT_ID:
-				return getDefaultRenderKitId();
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_VALIDATORS:
-				return getDefaultValidators();
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_VALUE:
-				return getDefaultValue();
-			case FacesConfigPackage.DOCUMENT_ROOT__DESCRIPTION:
-				return getDescription();
-			case FacesConfigPackage.DOCUMENT_ROOT__DISPLAY_NAME:
-				return getDisplayName();
-			case FacesConfigPackage.DOCUMENT_ROOT__EXCEPTION_HANDLER_FACTORY:
-				return getExceptionHandlerFactory();
-			case FacesConfigPackage.DOCUMENT_ROOT__EXTERNAL_CONTEXT_FACTORY:
-				return getExternalContextFactory();
-			case FacesConfigPackage.DOCUMENT_ROOT__FACES_CONFIG:
-				return getFacesConfig();
-			case FacesConfigPackage.DOCUMENT_ROOT__FACES_CONTEXT_FACTORY:
-				return getFacesContextFactory();
-			case FacesConfigPackage.DOCUMENT_ROOT__FACET:
-				return getFacet();
-			case FacesConfigPackage.DOCUMENT_ROOT__FACET_EXTENSION:
-				return getFacetExtension();
-			case FacesConfigPackage.DOCUMENT_ROOT__FACET_NAME:
-				return getFacetName();
-			case FacesConfigPackage.DOCUMENT_ROOT__FACTORY:
-				return getFactory();
-			case FacesConfigPackage.DOCUMENT_ROOT__FROM_ACTION:
-				return getFromAction();
-			case FacesConfigPackage.DOCUMENT_ROOT__FROM_OUTCOME:
-				return getFromOutcome();
-			case FacesConfigPackage.DOCUMENT_ROOT__FROM_VIEW_ID:
-				return getFromViewId();
-			case FacesConfigPackage.DOCUMENT_ROOT__ICON:
-				return getIcon();
-			case FacesConfigPackage.DOCUMENT_ROOT__IF:
-				return getIf();
-			case FacesConfigPackage.DOCUMENT_ROOT__KEY:
-				return getKey();
-			case FacesConfigPackage.DOCUMENT_ROOT__KEY_CLASS:
-				return getKeyClass();
-			case FacesConfigPackage.DOCUMENT_ROOT__LARGE_ICON:
-				return getLargeIcon();
-			case FacesConfigPackage.DOCUMENT_ROOT__LIFECYCLE:
-				return getLifecycle();
-			case FacesConfigPackage.DOCUMENT_ROOT__LIFECYCLE_FACTORY:
-				return getLifecycleFactory();
-			case FacesConfigPackage.DOCUMENT_ROOT__LIST_ENTRIES:
-				return getListEntries();
-			case FacesConfigPackage.DOCUMENT_ROOT__LOCALE_CONFIG:
-				return getLocaleConfig();
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN:
-				return getManagedBean();
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN_CLASS:
-				return getManagedBeanClass();
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN_NAME:
-				return getManagedBeanName();
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN_SCOPE:
-				return getManagedBeanScope();
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_PROPERTY:
-				return getManagedProperty();
-			case FacesConfigPackage.DOCUMENT_ROOT__MAP_ENTRIES:
-				return getMapEntries();
-			case FacesConfigPackage.DOCUMENT_ROOT__MAP_ENTRY:
-				return getMapEntry();
-			case FacesConfigPackage.DOCUMENT_ROOT__MESSAGE_BUNDLE:
-				return getMessageBundle();
-			case FacesConfigPackage.DOCUMENT_ROOT__NAME:
-				return getName();
-			case FacesConfigPackage.DOCUMENT_ROOT__NAVIGATION_CASE:
-				return getNavigationCase();
-			case FacesConfigPackage.DOCUMENT_ROOT__NAVIGATION_HANDLER:
-				return getNavigationHandler();
-			case FacesConfigPackage.DOCUMENT_ROOT__NAVIGATION_RULE:
-				return getNavigationRule();
-			case FacesConfigPackage.DOCUMENT_ROOT__NULL_VALUE:
-				return getNullValue();
-			case FacesConfigPackage.DOCUMENT_ROOT__ORDERING:
-				return getOrdering();
-			case FacesConfigPackage.DOCUMENT_ROOT__ORDERING_ORDERING:
-				return getOrderingOrdering();
-			case FacesConfigPackage.DOCUMENT_ROOT__OTHERS:
-				return getOthers();
-			case FacesConfigPackage.DOCUMENT_ROOT__PARTIAL_VIEW_CONTEXT_FACTORY:
-				return getPartialViewContextFactory();
-			case FacesConfigPackage.DOCUMENT_ROOT__PHASE_LISTENER:
-				return getPhaseListener();
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY:
-				return getProperty();
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_CLASS:
-				return getPropertyClass();
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_EXTENSION:
-				return getPropertyExtension();
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_NAME:
-				return getPropertyName();
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_RESOLVER:
-				return getPropertyResolver();
-			case FacesConfigPackage.DOCUMENT_ROOT__REDIRECT:
-				return getRedirect();
-			case FacesConfigPackage.DOCUMENT_ROOT__REDIRECT_VIEW_PARAM:
-				return getRedirectViewParam();
-			case FacesConfigPackage.DOCUMENT_ROOT__REFERENCED_BEAN:
-				return getReferencedBean();
-			case FacesConfigPackage.DOCUMENT_ROOT__REFERENCED_BEAN_CLASS:
-				return getReferencedBeanClass();
-			case FacesConfigPackage.DOCUMENT_ROOT__REFERENCED_BEAN_NAME:
-				return getReferencedBeanName();
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER:
-				return getRenderer();
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER_CLASS:
-				return getRendererClass();
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER_EXTENSION:
-				return getRendererExtension();
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER_TYPE:
-				return getRendererType();
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT:
-				return getRenderKit();
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT_CLASS:
-				return getRenderKitClass();
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT_FACTORY:
-				return getRenderKitFactory();
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT_ID:
-				return getRenderKitId();
-			case FacesConfigPackage.DOCUMENT_ROOT__RESOURCE_HANDLER:
-				return getResourceHandler();
-			case FacesConfigPackage.DOCUMENT_ROOT__SMALL_ICON:
-				return getSmallIcon();
-			case FacesConfigPackage.DOCUMENT_ROOT__SOURCE_CLASS:
-				return getSourceClass();
-			case FacesConfigPackage.DOCUMENT_ROOT__STATE_MANAGER:
-				return getStateManager();
-			case FacesConfigPackage.DOCUMENT_ROOT__SUGGESTED_VALUE:
-				return getSuggestedValue();
-			case FacesConfigPackage.DOCUMENT_ROOT__SUPPORTED_LOCALE:
-				return getSupportedLocale();
-			case FacesConfigPackage.DOCUMENT_ROOT__SYSTEM_EVENT_CLASS:
-				return getSystemEventClass();
-			case FacesConfigPackage.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER:
-				return getSystemEventListener();
-			case FacesConfigPackage.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER_CLASS:
-				return getSystemEventListenerClass();
-			case FacesConfigPackage.DOCUMENT_ROOT__TAG_HANDLER_DELEGATE_FACTORY:
-				return getTagHandlerDelegateFactory();
-			case FacesConfigPackage.DOCUMENT_ROOT__TO_VIEW_ID:
-				return getToViewId();
-			case FacesConfigPackage.DOCUMENT_ROOT__VALIDATOR:
-				return getValidator();
-			case FacesConfigPackage.DOCUMENT_ROOT__VALIDATOR_CLASS:
-				return getValidatorClass();
-			case FacesConfigPackage.DOCUMENT_ROOT__VALIDATOR_ID:
-				return getValidatorId();
-			case FacesConfigPackage.DOCUMENT_ROOT__VALUE:
-				return getValue();
-			case FacesConfigPackage.DOCUMENT_ROOT__VALUE_CLASS:
-				return getValueClass();
-			case FacesConfigPackage.DOCUMENT_ROOT__VARIABLE_RESOLVER:
-				return getVariableResolver();
-			case FacesConfigPackage.DOCUMENT_ROOT__VIEW_DECLARATION_LANGUAGE_FACTORY:
-				return getViewDeclarationLanguageFactory();
-			case FacesConfigPackage.DOCUMENT_ROOT__VIEW_HANDLER:
-				return getViewHandler();
-			case FacesConfigPackage.DOCUMENT_ROOT__VISIT_CONTEXT_FACTORY:
-				return getVisitContextFactory();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.DOCUMENT_ROOT__MIXED:
-				((FeatureMap.Internal)getMixed()).set(newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__XMLNS_PREFIX_MAP:
-				((EStructuralFeature.Setting)getXMLNSPrefixMap()).set(newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__XSI_SCHEMA_LOCATION:
-				((EStructuralFeature.Setting)getXSISchemaLocation()).set(newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__ABSOLUTE_ORDERING:
-				setAbsoluteOrdering((AbsoluteOrderingType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__ACTION_LISTENER:
-				setActionListener((ActionListenerType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__APPLICATION:
-				setApplication((ApplicationType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__APPLICATION_FACTORY:
-				setApplicationFactory((ApplicationFactoryType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE:
-				setAttribute((AttributeType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE_CLASS:
-				setAttributeClass((AttributeClassType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE_EXTENSION:
-				setAttributeExtension((AttributeExtensionType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE_NAME:
-				setAttributeName((AttributeNameType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR:
-				setBehavior((BehaviorType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR_CLASS:
-				setBehaviorClass((BehaviorClassType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR_ID:
-				setBehaviorId((BehaviorIdType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR_EXTENSION:
-				setBehaviorExtension((BehaviorExtensionType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT:
-				setComponent((ComponentType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_CLASS:
-				setComponentClass((ComponentClassType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_EXTENSION:
-				setComponentExtension((ComponentExtensionType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_FAMILY:
-				setComponentFamily((ComponentFamilyType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_TYPE:
-				setComponentType((ComponentTypeType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER:
-				setConverter((ConverterType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER_CLASS:
-				setConverterClass((ConverterClassType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER_FOR_CLASS:
-				setConverterForClass((ConverterForClassType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER_ID:
-				setConverterId((ConverterIdType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_LOCALE:
-				setDefaultLocale((DefaultLocaleType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_RENDER_KIT_ID:
-				setDefaultRenderKitId((DefaultRenderKitIdType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_VALIDATORS:
-				setDefaultValidators((DefaultValidatorsType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_VALUE:
-				setDefaultValue((DefaultValueType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__DESCRIPTION:
-				setDescription((DescriptionType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__DISPLAY_NAME:
-				setDisplayName((DisplayNameType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__EXCEPTION_HANDLER_FACTORY:
-				setExceptionHandlerFactory((ExceptionHandlerFactoryType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__EXTERNAL_CONTEXT_FACTORY:
-				setExternalContextFactory((ExternalContextFactoryType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__FACES_CONFIG:
-				setFacesConfig((FacesConfigType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__FACES_CONTEXT_FACTORY:
-				setFacesContextFactory((FacesContextFactoryType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__FACET:
-				setFacet((FacetType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__FACET_EXTENSION:
-				setFacetExtension((FacetExtensionType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__FACET_NAME:
-				setFacetName((FacetNameType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__FACTORY:
-				setFactory((FactoryType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__FROM_ACTION:
-				setFromAction((FromActionType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__FROM_OUTCOME:
-				setFromOutcome((FromOutcomeType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__FROM_VIEW_ID:
-				setFromViewId((FromViewIdType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__ICON:
-				setIcon((IconType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__IF:
-				setIf((IfType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__KEY:
-				setKey((KeyType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__KEY_CLASS:
-				setKeyClass((KeyClassType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__LARGE_ICON:
-				setLargeIcon((LargeIconType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__LIFECYCLE:
-				setLifecycle((LifecycleType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__LIFECYCLE_FACTORY:
-				setLifecycleFactory((LifecycleFactoryType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__LIST_ENTRIES:
-				setListEntries((ListEntriesType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__LOCALE_CONFIG:
-				setLocaleConfig((LocaleConfigType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN:
-				setManagedBean((ManagedBeanType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN_CLASS:
-				setManagedBeanClass((ManagedBeanClassType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN_NAME:
-				setManagedBeanName((ManagedBeanNameType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN_SCOPE:
-				setManagedBeanScope((ManagedBeanScopeType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_PROPERTY:
-				setManagedProperty((ManagedPropertyType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__MAP_ENTRIES:
-				setMapEntries((MapEntriesType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__MAP_ENTRY:
-				setMapEntry((MapEntryType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__MESSAGE_BUNDLE:
-				setMessageBundle((MessageBundleType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__NAME:
-				setName((NameType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__NAVIGATION_CASE:
-				setNavigationCase((NavigationCaseType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__NAVIGATION_HANDLER:
-				setNavigationHandler((NavigationHandlerType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__NAVIGATION_RULE:
-				setNavigationRule((NavigationRuleType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__NULL_VALUE:
-				setNullValue((NullValueType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__ORDERING:
-				setOrdering((OrderingType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__ORDERING_ORDERING:
-				setOrderingOrdering((OrderingOrderingType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__OTHERS:
-				setOthers((OrderingOthersType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__PARTIAL_VIEW_CONTEXT_FACTORY:
-				setPartialViewContextFactory((PartialViewContextFactoryType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__PHASE_LISTENER:
-				setPhaseListener((PhaseListenerType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY:
-				setProperty((PropertyType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_CLASS:
-				setPropertyClass((PropertyClassType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_EXTENSION:
-				setPropertyExtension((PropertyExtensionType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_NAME:
-				setPropertyName((PropertyNameType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_RESOLVER:
-				setPropertyResolver((PropertyResolverType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__REDIRECT:
-				setRedirect((RedirectType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__REDIRECT_VIEW_PARAM:
-				setRedirectViewParam((RedirectViewParamType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__REFERENCED_BEAN:
-				setReferencedBean((ReferencedBeanType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__REFERENCED_BEAN_CLASS:
-				setReferencedBeanClass((ReferencedBeanClassType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__REFERENCED_BEAN_NAME:
-				setReferencedBeanName((ReferencedBeanNameType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER:
-				setRenderer((RendererType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER_CLASS:
-				setRendererClass((RendererClassType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER_EXTENSION:
-				setRendererExtension((RendererExtensionType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER_TYPE:
-				setRendererType((RendererTypeType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT:
-				setRenderKit((RenderKitType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT_CLASS:
-				setRenderKitClass((RenderKitClassType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT_FACTORY:
-				setRenderKitFactory((RenderKitFactoryType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT_ID:
-				setRenderKitId((RenderKitIdType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__RESOURCE_HANDLER:
-				setResourceHandler((ResourceHandlerType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__SMALL_ICON:
-				setSmallIcon((SmallIconType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__SOURCE_CLASS:
-				setSourceClass((SourceClassType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__STATE_MANAGER:
-				setStateManager((StateManagerType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__SUGGESTED_VALUE:
-				setSuggestedValue((SuggestedValueType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__SUPPORTED_LOCALE:
-				setSupportedLocale((SupportedLocaleType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__SYSTEM_EVENT_CLASS:
-				setSystemEventClass((SystemEventClassType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER:
-				setSystemEventListener((SystemEventListenerType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER_CLASS:
-				setSystemEventListenerClass((SystemEventListenerClassType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__TAG_HANDLER_DELEGATE_FACTORY:
-				setTagHandlerDelegateFactory((TagHandlerDelegateFactoryType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__TO_VIEW_ID:
-				setToViewId((ToViewIdType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__VALIDATOR:
-				setValidator((ValidatorType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__VALIDATOR_CLASS:
-				setValidatorClass((ValidatorClassType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__VALIDATOR_ID:
-				setValidatorId((ValidatorIdType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__VALUE:
-				setValue((ValueType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__VALUE_CLASS:
-				setValueClass((ValueClassType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__VARIABLE_RESOLVER:
-				setVariableResolver((VariableResolverType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__VIEW_DECLARATION_LANGUAGE_FACTORY:
-				setViewDeclarationLanguageFactory((ViewDeclarationLanguageFactoryType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__VIEW_HANDLER:
-				setViewHandler((ViewHandlerType)newValue);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__VISIT_CONTEXT_FACTORY:
-				setVisitContextFactory((VisitContextFactoryType)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.DOCUMENT_ROOT__MIXED:
-				getMixed().clear();
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__XMLNS_PREFIX_MAP:
-				getXMLNSPrefixMap().clear();
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__XSI_SCHEMA_LOCATION:
-				getXSISchemaLocation().clear();
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__ABSOLUTE_ORDERING:
-				setAbsoluteOrdering((AbsoluteOrderingType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__ACTION_LISTENER:
-				setActionListener((ActionListenerType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__APPLICATION:
-				setApplication((ApplicationType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__APPLICATION_FACTORY:
-				setApplicationFactory((ApplicationFactoryType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE:
-				setAttribute((AttributeType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE_CLASS:
-				setAttributeClass((AttributeClassType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE_EXTENSION:
-				setAttributeExtension((AttributeExtensionType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE_NAME:
-				setAttributeName((AttributeNameType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR:
-				setBehavior((BehaviorType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR_CLASS:
-				setBehaviorClass((BehaviorClassType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR_ID:
-				setBehaviorId((BehaviorIdType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR_EXTENSION:
-				setBehaviorExtension((BehaviorExtensionType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT:
-				setComponent((ComponentType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_CLASS:
-				setComponentClass((ComponentClassType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_EXTENSION:
-				setComponentExtension((ComponentExtensionType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_FAMILY:
-				setComponentFamily((ComponentFamilyType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_TYPE:
-				setComponentType((ComponentTypeType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER:
-				setConverter((ConverterType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER_CLASS:
-				setConverterClass((ConverterClassType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER_FOR_CLASS:
-				setConverterForClass((ConverterForClassType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER_ID:
-				setConverterId((ConverterIdType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_LOCALE:
-				setDefaultLocale((DefaultLocaleType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_RENDER_KIT_ID:
-				setDefaultRenderKitId((DefaultRenderKitIdType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_VALIDATORS:
-				setDefaultValidators((DefaultValidatorsType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_VALUE:
-				setDefaultValue((DefaultValueType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__DESCRIPTION:
-				setDescription((DescriptionType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__DISPLAY_NAME:
-				setDisplayName((DisplayNameType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__EXCEPTION_HANDLER_FACTORY:
-				setExceptionHandlerFactory((ExceptionHandlerFactoryType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__EXTERNAL_CONTEXT_FACTORY:
-				setExternalContextFactory((ExternalContextFactoryType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__FACES_CONFIG:
-				setFacesConfig((FacesConfigType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__FACES_CONTEXT_FACTORY:
-				setFacesContextFactory((FacesContextFactoryType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__FACET:
-				setFacet((FacetType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__FACET_EXTENSION:
-				setFacetExtension((FacetExtensionType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__FACET_NAME:
-				setFacetName((FacetNameType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__FACTORY:
-				setFactory((FactoryType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__FROM_ACTION:
-				setFromAction((FromActionType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__FROM_OUTCOME:
-				setFromOutcome((FromOutcomeType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__FROM_VIEW_ID:
-				setFromViewId((FromViewIdType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__ICON:
-				setIcon((IconType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__IF:
-				setIf((IfType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__KEY:
-				setKey((KeyType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__KEY_CLASS:
-				setKeyClass((KeyClassType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__LARGE_ICON:
-				setLargeIcon((LargeIconType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__LIFECYCLE:
-				setLifecycle((LifecycleType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__LIFECYCLE_FACTORY:
-				setLifecycleFactory((LifecycleFactoryType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__LIST_ENTRIES:
-				setListEntries((ListEntriesType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__LOCALE_CONFIG:
-				setLocaleConfig((LocaleConfigType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN:
-				setManagedBean((ManagedBeanType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN_CLASS:
-				setManagedBeanClass((ManagedBeanClassType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN_NAME:
-				setManagedBeanName((ManagedBeanNameType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN_SCOPE:
-				setManagedBeanScope((ManagedBeanScopeType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_PROPERTY:
-				setManagedProperty((ManagedPropertyType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__MAP_ENTRIES:
-				setMapEntries((MapEntriesType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__MAP_ENTRY:
-				setMapEntry((MapEntryType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__MESSAGE_BUNDLE:
-				setMessageBundle((MessageBundleType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__NAME:
-				setName((NameType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__NAVIGATION_CASE:
-				setNavigationCase((NavigationCaseType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__NAVIGATION_HANDLER:
-				setNavigationHandler((NavigationHandlerType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__NAVIGATION_RULE:
-				setNavigationRule((NavigationRuleType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__NULL_VALUE:
-				setNullValue((NullValueType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__ORDERING:
-				setOrdering((OrderingType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__ORDERING_ORDERING:
-				setOrderingOrdering((OrderingOrderingType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__OTHERS:
-				setOthers((OrderingOthersType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__PARTIAL_VIEW_CONTEXT_FACTORY:
-				setPartialViewContextFactory((PartialViewContextFactoryType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__PHASE_LISTENER:
-				setPhaseListener((PhaseListenerType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY:
-				setProperty((PropertyType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_CLASS:
-				setPropertyClass((PropertyClassType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_EXTENSION:
-				setPropertyExtension((PropertyExtensionType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_NAME:
-				setPropertyName((PropertyNameType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_RESOLVER:
-				setPropertyResolver((PropertyResolverType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__REDIRECT:
-				setRedirect((RedirectType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__REDIRECT_VIEW_PARAM:
-				setRedirectViewParam((RedirectViewParamType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__REFERENCED_BEAN:
-				setReferencedBean((ReferencedBeanType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__REFERENCED_BEAN_CLASS:
-				setReferencedBeanClass((ReferencedBeanClassType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__REFERENCED_BEAN_NAME:
-				setReferencedBeanName((ReferencedBeanNameType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER:
-				setRenderer((RendererType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER_CLASS:
-				setRendererClass((RendererClassType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER_EXTENSION:
-				setRendererExtension((RendererExtensionType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER_TYPE:
-				setRendererType((RendererTypeType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT:
-				setRenderKit((RenderKitType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT_CLASS:
-				setRenderKitClass((RenderKitClassType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT_FACTORY:
-				setRenderKitFactory((RenderKitFactoryType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT_ID:
-				setRenderKitId((RenderKitIdType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__RESOURCE_HANDLER:
-				setResourceHandler((ResourceHandlerType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__SMALL_ICON:
-				setSmallIcon((SmallIconType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__SOURCE_CLASS:
-				setSourceClass((SourceClassType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__STATE_MANAGER:
-				setStateManager((StateManagerType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__SUGGESTED_VALUE:
-				setSuggestedValue((SuggestedValueType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__SUPPORTED_LOCALE:
-				setSupportedLocale((SupportedLocaleType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__SYSTEM_EVENT_CLASS:
-				setSystemEventClass((SystemEventClassType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER:
-				setSystemEventListener((SystemEventListenerType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER_CLASS:
-				setSystemEventListenerClass((SystemEventListenerClassType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__TAG_HANDLER_DELEGATE_FACTORY:
-				setTagHandlerDelegateFactory((TagHandlerDelegateFactoryType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__TO_VIEW_ID:
-				setToViewId((ToViewIdType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__VALIDATOR:
-				setValidator((ValidatorType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__VALIDATOR_CLASS:
-				setValidatorClass((ValidatorClassType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__VALIDATOR_ID:
-				setValidatorId((ValidatorIdType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__VALUE:
-				setValue((ValueType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__VALUE_CLASS:
-				setValueClass((ValueClassType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__VARIABLE_RESOLVER:
-				setVariableResolver((VariableResolverType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__VIEW_DECLARATION_LANGUAGE_FACTORY:
-				setViewDeclarationLanguageFactory((ViewDeclarationLanguageFactoryType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__VIEW_HANDLER:
-				setViewHandler((ViewHandlerType)null);
-				return;
-			case FacesConfigPackage.DOCUMENT_ROOT__VISIT_CONTEXT_FACTORY:
-				setVisitContextFactory((VisitContextFactoryType)null);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.DOCUMENT_ROOT__MIXED:
-				return mixed != null && !mixed.isEmpty();
-			case FacesConfigPackage.DOCUMENT_ROOT__XMLNS_PREFIX_MAP:
-				return xMLNSPrefixMap != null && !xMLNSPrefixMap.isEmpty();
-			case FacesConfigPackage.DOCUMENT_ROOT__XSI_SCHEMA_LOCATION:
-				return xSISchemaLocation != null && !xSISchemaLocation.isEmpty();
-			case FacesConfigPackage.DOCUMENT_ROOT__ABSOLUTE_ORDERING:
-				return getAbsoluteOrdering() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__ACTION_LISTENER:
-				return getActionListener() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__APPLICATION:
-				return getApplication() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__APPLICATION_FACTORY:
-				return getApplicationFactory() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE:
-				return getAttribute() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE_CLASS:
-				return getAttributeClass() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE_EXTENSION:
-				return getAttributeExtension() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__ATTRIBUTE_NAME:
-				return getAttributeName() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR:
-				return getBehavior() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR_CLASS:
-				return getBehaviorClass() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR_ID:
-				return getBehaviorId() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__BEHAVIOR_EXTENSION:
-				return getBehaviorExtension() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT:
-				return getComponent() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_CLASS:
-				return getComponentClass() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_EXTENSION:
-				return getComponentExtension() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_FAMILY:
-				return getComponentFamily() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__COMPONENT_TYPE:
-				return getComponentType() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER:
-				return getConverter() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER_CLASS:
-				return getConverterClass() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER_FOR_CLASS:
-				return getConverterForClass() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__CONVERTER_ID:
-				return getConverterId() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_LOCALE:
-				return getDefaultLocale() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_RENDER_KIT_ID:
-				return getDefaultRenderKitId() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_VALIDATORS:
-				return getDefaultValidators() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__DEFAULT_VALUE:
-				return getDefaultValue() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__DESCRIPTION:
-				return getDescription() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__DISPLAY_NAME:
-				return getDisplayName() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__EXCEPTION_HANDLER_FACTORY:
-				return getExceptionHandlerFactory() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__EXTERNAL_CONTEXT_FACTORY:
-				return getExternalContextFactory() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__FACES_CONFIG:
-				return getFacesConfig() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__FACES_CONTEXT_FACTORY:
-				return getFacesContextFactory() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__FACET:
-				return getFacet() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__FACET_EXTENSION:
-				return getFacetExtension() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__FACET_NAME:
-				return getFacetName() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__FACTORY:
-				return getFactory() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__FROM_ACTION:
-				return getFromAction() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__FROM_OUTCOME:
-				return getFromOutcome() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__FROM_VIEW_ID:
-				return getFromViewId() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__ICON:
-				return getIcon() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__IF:
-				return getIf() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__KEY:
-				return getKey() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__KEY_CLASS:
-				return getKeyClass() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__LARGE_ICON:
-				return getLargeIcon() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__LIFECYCLE:
-				return getLifecycle() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__LIFECYCLE_FACTORY:
-				return getLifecycleFactory() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__LIST_ENTRIES:
-				return getListEntries() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__LOCALE_CONFIG:
-				return getLocaleConfig() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN:
-				return getManagedBean() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN_CLASS:
-				return getManagedBeanClass() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN_NAME:
-				return getManagedBeanName() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_BEAN_SCOPE:
-				return getManagedBeanScope() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__MANAGED_PROPERTY:
-				return getManagedProperty() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__MAP_ENTRIES:
-				return getMapEntries() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__MAP_ENTRY:
-				return getMapEntry() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__MESSAGE_BUNDLE:
-				return getMessageBundle() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__NAME:
-				return getName() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__NAVIGATION_CASE:
-				return getNavigationCase() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__NAVIGATION_HANDLER:
-				return getNavigationHandler() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__NAVIGATION_RULE:
-				return getNavigationRule() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__NULL_VALUE:
-				return getNullValue() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__ORDERING:
-				return getOrdering() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__ORDERING_ORDERING:
-				return getOrderingOrdering() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__OTHERS:
-				return getOthers() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__PARTIAL_VIEW_CONTEXT_FACTORY:
-				return getPartialViewContextFactory() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__PHASE_LISTENER:
-				return getPhaseListener() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY:
-				return getProperty() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_CLASS:
-				return getPropertyClass() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_EXTENSION:
-				return getPropertyExtension() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_NAME:
-				return getPropertyName() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__PROPERTY_RESOLVER:
-				return getPropertyResolver() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__REDIRECT:
-				return getRedirect() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__REDIRECT_VIEW_PARAM:
-				return getRedirectViewParam() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__REFERENCED_BEAN:
-				return getReferencedBean() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__REFERENCED_BEAN_CLASS:
-				return getReferencedBeanClass() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__REFERENCED_BEAN_NAME:
-				return getReferencedBeanName() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER:
-				return getRenderer() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER_CLASS:
-				return getRendererClass() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER_EXTENSION:
-				return getRendererExtension() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDERER_TYPE:
-				return getRendererType() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT:
-				return getRenderKit() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT_CLASS:
-				return getRenderKitClass() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT_FACTORY:
-				return getRenderKitFactory() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__RENDER_KIT_ID:
-				return getRenderKitId() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__RESOURCE_HANDLER:
-				return getResourceHandler() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__SMALL_ICON:
-				return getSmallIcon() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__SOURCE_CLASS:
-				return getSourceClass() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__STATE_MANAGER:
-				return getStateManager() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__SUGGESTED_VALUE:
-				return getSuggestedValue() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__SUPPORTED_LOCALE:
-				return getSupportedLocale() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__SYSTEM_EVENT_CLASS:
-				return getSystemEventClass() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER:
-				return getSystemEventListener() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER_CLASS:
-				return getSystemEventListenerClass() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__TAG_HANDLER_DELEGATE_FACTORY:
-				return getTagHandlerDelegateFactory() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__TO_VIEW_ID:
-				return getToViewId() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__VALIDATOR:
-				return getValidator() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__VALIDATOR_CLASS:
-				return getValidatorClass() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__VALIDATOR_ID:
-				return getValidatorId() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__VALUE:
-				return getValue() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__VALUE_CLASS:
-				return getValueClass() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__VARIABLE_RESOLVER:
-				return getVariableResolver() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__VIEW_DECLARATION_LANGUAGE_FACTORY:
-				return getViewDeclarationLanguageFactory() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__VIEW_HANDLER:
-				return getViewHandler() != null;
-			case FacesConfigPackage.DOCUMENT_ROOT__VISIT_CONTEXT_FACTORY:
-				return getVisitContextFactory() != null;
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (mixed: ");//$NON-NLS-1$
-		result.append(mixed);
-		result.append(')');
-		return result.toString();
-	}
-
-} //DocumentRootImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DynamicAttributeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DynamicAttributeImpl.java
deleted file mode 100644
index 0105411..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DynamicAttributeImpl.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.DynamicAttribute;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Dynamic Attribute</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DynamicAttributeImpl#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DynamicAttributeImpl#getValue <em>Value</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class DynamicAttributeImpl extends EObjectImpl implements DynamicAttribute {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * 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 DynamicAttributeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.DYNAMIC_ATTRIBUTE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getName() {
-		return name;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void setName(String newName) {
-		String oldName = name;
-		name = newName;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.DYNAMIC_ATTRIBUTE__NAME, oldName, name));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getValue() {
-		return value;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void setValue(String newValue) {
-		String oldValue = value;
-		value = newValue;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.DYNAMIC_ATTRIBUTE__VALUE, oldValue, value));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.DYNAMIC_ATTRIBUTE__NAME:
-				return getName();
-			case FacesConfigPackage.DYNAMIC_ATTRIBUTE__VALUE:
-				return getValue();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.DYNAMIC_ATTRIBUTE__NAME:
-				setName((String)newValue);
-				return;
-			case FacesConfigPackage.DYNAMIC_ATTRIBUTE__VALUE:
-				setValue((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.DYNAMIC_ATTRIBUTE__NAME:
-				setName(NAME_EDEFAULT);
-				return;
-			case FacesConfigPackage.DYNAMIC_ATTRIBUTE__VALUE:
-				setValue(VALUE_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.DYNAMIC_ATTRIBUTE__NAME:
-				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-			case FacesConfigPackage.DYNAMIC_ATTRIBUTE__VALUE:
-				return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-    public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(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();
-	}
-
-} //DynamicAttributeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DynamicElementImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DynamicElementImpl.java
deleted file mode 100644
index 46b6e8a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/DynamicElementImpl.java
+++ /dev/null
@@ -1,314 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.EObjectResolvingEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.DynamicAttribute;
-import org.eclipse.jst.jsf.facesconfig.emf.DynamicElement;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Dynamic Element</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DynamicElementImpl#getChildNodes <em>Child Nodes</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DynamicElementImpl#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DynamicElementImpl#getAttributes <em>Attributes</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.DynamicElementImpl#getTextContent <em>Text Content</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class DynamicElementImpl extends EObjectImpl implements DynamicElement {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getChildNodes() <em>Child Nodes</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getChildNodes()
-	 * @generated
-	 * @ordered
-	 */
-    protected EList childNodes;
-
-    /**
-	 * 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 #getAttributes() <em>Attributes</em>}' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getAttributes()
-	 * @generated
-	 * @ordered
-	 */
-    protected EList attributes;
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-    protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-    protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected DynamicElementImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.DYNAMIC_ELEMENT;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EList getChildNodes() {
-		if (childNodes == null) {
-			childNodes = new EObjectContainmentEList(DynamicElement.class, this, FacesConfigPackage.DYNAMIC_ELEMENT__CHILD_NODES);
-		}
-		return childNodes;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EList getAttributes() {
-		if (attributes == null) {
-			attributes = new EObjectResolvingEList(DynamicAttribute.class, this, FacesConfigPackage.DYNAMIC_ELEMENT__ATTRIBUTES);
-		}
-		return attributes;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.DYNAMIC_ELEMENT__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getName() {
-		return name;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void setName(String newName) {
-		String oldName = name;
-		name = newName;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.DYNAMIC_ELEMENT__NAME, oldName, name));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.DYNAMIC_ELEMENT__CHILD_NODES:
-				return ((InternalEList)getChildNodes()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.DYNAMIC_ELEMENT__CHILD_NODES:
-				return getChildNodes();
-			case FacesConfigPackage.DYNAMIC_ELEMENT__NAME:
-				return getName();
-			case FacesConfigPackage.DYNAMIC_ELEMENT__ATTRIBUTES:
-				return getAttributes();
-			case FacesConfigPackage.DYNAMIC_ELEMENT__TEXT_CONTENT:
-				return getTextContent();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.DYNAMIC_ELEMENT__CHILD_NODES:
-				getChildNodes().clear();
-				getChildNodes().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.DYNAMIC_ELEMENT__NAME:
-				setName((String)newValue);
-				return;
-			case FacesConfigPackage.DYNAMIC_ELEMENT__ATTRIBUTES:
-				getAttributes().clear();
-				getAttributes().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.DYNAMIC_ELEMENT__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.DYNAMIC_ELEMENT__CHILD_NODES:
-				getChildNodes().clear();
-				return;
-			case FacesConfigPackage.DYNAMIC_ELEMENT__NAME:
-				setName(NAME_EDEFAULT);
-				return;
-			case FacesConfigPackage.DYNAMIC_ELEMENT__ATTRIBUTES:
-				getAttributes().clear();
-				return;
-			case FacesConfigPackage.DYNAMIC_ELEMENT__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.DYNAMIC_ELEMENT__CHILD_NODES:
-				return childNodes != null && !childNodes.isEmpty();
-			case FacesConfigPackage.DYNAMIC_ELEMENT__NAME:
-				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-			case FacesConfigPackage.DYNAMIC_ELEMENT__ATTRIBUTES:
-				return attributes != null && !attributes.isEmpty();
-			case FacesConfigPackage.DYNAMIC_ELEMENT__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-    public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (name: ");//$NON-NLS-1$
-		result.append(name);
-		result.append(", textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(')');
-		return result.toString();
-	}
-
-} //DynamicElementImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ELResolverTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ELResolverTypeImpl.java
deleted file mode 100644
index 60006fc..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ELResolverTypeImpl.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.ELResolverType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>EL Resolver Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ELResolverTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ELResolverTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ELResolverTypeImpl extends EObjectImpl implements ELResolverType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-    protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-    protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-    protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-    protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected ELResolverTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.EL_RESOLVER_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.EL_RESOLVER_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.EL_RESOLVER_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.EL_RESOLVER_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.EL_RESOLVER_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.EL_RESOLVER_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.EL_RESOLVER_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.EL_RESOLVER_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.EL_RESOLVER_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.EL_RESOLVER_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.EL_RESOLVER_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-    public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ELResolverTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ExceptionHandlerFactoryTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ExceptionHandlerFactoryTypeImpl.java
deleted file mode 100644
index fa5e031..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ExceptionHandlerFactoryTypeImpl.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.ExceptionHandlerFactoryType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Exception Handler Factory Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ExceptionHandlerFactoryTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ExceptionHandlerFactoryTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ExceptionHandlerFactoryTypeImpl extends EObjectImpl implements ExceptionHandlerFactoryType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ExceptionHandlerFactoryTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.EXCEPTION_HANDLER_FACTORY_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.EXCEPTION_HANDLER_FACTORY_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.EXCEPTION_HANDLER_FACTORY_TYPE__ID, oldId, id));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.EXCEPTION_HANDLER_FACTORY_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.EXCEPTION_HANDLER_FACTORY_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.EXCEPTION_HANDLER_FACTORY_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.EXCEPTION_HANDLER_FACTORY_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.EXCEPTION_HANDLER_FACTORY_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.EXCEPTION_HANDLER_FACTORY_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.EXCEPTION_HANDLER_FACTORY_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.EXCEPTION_HANDLER_FACTORY_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ExceptionHandlerFactoryTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ExtensionTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ExtensionTypeImpl.java
deleted file mode 100644
index acecd7c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ExtensionTypeImpl.java
+++ /dev/null
@@ -1,263 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectResolvingEList;
-import org.eclipse.jst.jsf.facesconfig.emf.DynamicElement;
-import org.eclipse.jst.jsf.facesconfig.emf.ExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Extension Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ExtensionTypeImpl#getChildNodes <em>Child Nodes</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ExtensionTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ExtensionTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public abstract class ExtensionTypeImpl extends EObjectImpl implements ExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getChildNodes() <em>Child Nodes</em>}' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getChildNodes()
-	 * @generated
-	 * @ordered
-	 */
-    protected EList childNodes;
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-    protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-    protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-    protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-    protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected ExtensionTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.EXTENSION_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EList getChildNodes() {
-		if (childNodes == null) {
-			childNodes = new EObjectResolvingEList(DynamicElement.class, this, FacesConfigPackage.EXTENSION_TYPE__CHILD_NODES);
-		}
-		return childNodes;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.EXTENSION_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.EXTENSION_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.EXTENSION_TYPE__CHILD_NODES:
-				return getChildNodes();
-			case FacesConfigPackage.EXTENSION_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.EXTENSION_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.EXTENSION_TYPE__CHILD_NODES:
-				getChildNodes().clear();
-				getChildNodes().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.EXTENSION_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.EXTENSION_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.EXTENSION_TYPE__CHILD_NODES:
-				getChildNodes().clear();
-				return;
-			case FacesConfigPackage.EXTENSION_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.EXTENSION_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.EXTENSION_TYPE__CHILD_NODES:
-				return childNodes != null && !childNodes.isEmpty();
-			case FacesConfigPackage.EXTENSION_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.EXTENSION_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-    public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ExtensionTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ExternalContextFactoryTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ExternalContextFactoryTypeImpl.java
deleted file mode 100644
index f9d3685..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ExternalContextFactoryTypeImpl.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.ExternalContextFactoryType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>External Context Factory Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ExternalContextFactoryTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ExternalContextFactoryTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ExternalContextFactoryTypeImpl extends EObjectImpl implements ExternalContextFactoryType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ExternalContextFactoryTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.EXTERNAL_CONTEXT_FACTORY_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.EXTERNAL_CONTEXT_FACTORY_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.EXTERNAL_CONTEXT_FACTORY_TYPE__ID, oldId, id));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.EXTERNAL_CONTEXT_FACTORY_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.EXTERNAL_CONTEXT_FACTORY_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.EXTERNAL_CONTEXT_FACTORY_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.EXTERNAL_CONTEXT_FACTORY_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.EXTERNAL_CONTEXT_FACTORY_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.EXTERNAL_CONTEXT_FACTORY_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.EXTERNAL_CONTEXT_FACTORY_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.EXTERNAL_CONTEXT_FACTORY_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: ");//$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: ");//$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ExternalContextFactoryTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacesConfigExtensionTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacesConfigExtensionTypeImpl.java
deleted file mode 100644
index 6f08de3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacesConfigExtensionTypeImpl.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Extension Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * </p>
- *
- * @generated
- */
-public class FacesConfigExtensionTypeImpl extends ExtensionTypeImpl implements FacesConfigExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    @SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected FacesConfigExtensionTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.FACES_CONFIG_EXTENSION_TYPE;
-	}
-
-} //FacesConfigExtensionTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacesConfigFactoryImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacesConfigFactoryImpl.java
deleted file mode 100644
index 9411297..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacesConfigFactoryImpl.java
+++ /dev/null
@@ -1,1440 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.jst.jsf.facesconfig.emf.*;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model <b>Factory</b>.
- * <!-- end-user-doc -->
- * @generated
- */
-public class FacesConfigFactoryImpl extends EFactoryImpl implements FacesConfigFactory {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * Creates the default factory implementation.
-	 * <!-- begin-user-doc -->
-     * @return the factory instance 
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-    public static FacesConfigFactory init() {
-		try {
-			FacesConfigFactory theFacesConfigFactory = (FacesConfigFactory)EPackage.Registry.INSTANCE.getEFactory("http://www.eclipse.org/webtools/jsf/schema/facesconfig.xsd"); //$NON-NLS-1$ 
-			if (theFacesConfigFactory != null) {
-				return theFacesConfigFactory;
-			}
-		}
-		catch (Exception exception) {
-			EcorePlugin.INSTANCE.log(exception);
-		}
-		return new FacesConfigFactoryImpl();
-	}
-
-    /**
-	 * Creates an instance of the factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FacesConfigFactoryImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EObject create(EClass eClass) {
-		switch (eClass.getClassifierID()) {
-			case FacesConfigPackage.ABSOLUTE_ORDERING_TYPE: return createAbsoluteOrderingType();
-			case FacesConfigPackage.ACTION_LISTENER_TYPE: return createActionListenerType();
-			case FacesConfigPackage.APPLICATION_FACTORY_TYPE: return createApplicationFactoryType();
-			case FacesConfigPackage.APPLICATION_TYPE: return createApplicationType();
-			case FacesConfigPackage.APPLICATION_EXTENSION_TYPE: return createApplicationExtensionType();
-			case FacesConfigPackage.ATTRIBUTE_CLASS_TYPE: return createAttributeClassType();
-			case FacesConfigPackage.ATTRIBUTE_EXTENSION_TYPE: return createAttributeExtensionType();
-			case FacesConfigPackage.ATTRIBUTE_NAME_TYPE: return createAttributeNameType();
-			case FacesConfigPackage.ATTRIBUTE_TYPE: return createAttributeType();
-			case FacesConfigPackage.BEHAVIOR_CLASS_TYPE: return createBehaviorClassType();
-			case FacesConfigPackage.BEHAVIOR_ID_TYPE: return createBehaviorIdType();
-			case FacesConfigPackage.BEHAVIOR_TYPE: return createBehaviorType();
-			case FacesConfigPackage.BEHAVIOR_EXTENSION_TYPE: return createBehaviorExtensionType();
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE: return createClientBehaviorRendererClassType();
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE: return createClientBehaviorRendererType();
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE: return createClientBehaviorRendererTypeType();
-			case FacesConfigPackage.COMPONENT_CLASS_TYPE: return createComponentClassType();
-			case FacesConfigPackage.COMPONENT_EXTENSION_TYPE: return createComponentExtensionType();
-			case FacesConfigPackage.COMPONENT_FAMILY_TYPE: return createComponentFamilyType();
-			case FacesConfigPackage.COMPONENT_TYPE: return createComponentType();
-			case FacesConfigPackage.COMPONENT_TYPE_TYPE: return createComponentTypeType();
-			case FacesConfigPackage.CONVERTER_CLASS_TYPE: return createConverterClassType();
-			case FacesConfigPackage.CONVERTER_FOR_CLASS_TYPE: return createConverterForClassType();
-			case FacesConfigPackage.CONVERTER_ID_TYPE: return createConverterIdType();
-			case FacesConfigPackage.CONVERTER_TYPE: return createConverterType();
-			case FacesConfigPackage.CONVERTER_EXTENSION_TYPE: return createConverterExtensionType();
-			case FacesConfigPackage.DEFAULT_LOCALE_TYPE: return createDefaultLocaleType();
-			case FacesConfigPackage.DEFAULT_RENDER_KIT_ID_TYPE: return createDefaultRenderKitIdType();
-			case FacesConfigPackage.DEFAULT_VALIDATORS_TYPE: return createDefaultValidatorsType();
-			case FacesConfigPackage.DEFAULT_VALUE_TYPE: return createDefaultValueType();
-			case FacesConfigPackage.DESCRIPTION_TYPE: return createDescriptionType();
-			case FacesConfigPackage.DISPLAY_NAME_TYPE: return createDisplayNameType();
-			case FacesConfigPackage.DOCUMENT_ROOT: return createDocumentRoot();
-			case FacesConfigPackage.DYNAMIC_ATTRIBUTE: return createDynamicAttribute();
-			case FacesConfigPackage.DYNAMIC_ELEMENT: return createDynamicElement();
-			case FacesConfigPackage.EL_RESOLVER_TYPE: return createELResolverType();
-			case FacesConfigPackage.EXCEPTION_HANDLER_FACTORY_TYPE: return createExceptionHandlerFactoryType();
-			case FacesConfigPackage.EXTERNAL_CONTEXT_FACTORY_TYPE: return createExternalContextFactoryType();
-			case FacesConfigPackage.FACES_CONFIG_TYPE: return createFacesConfigType();
-			case FacesConfigPackage.FACES_CONFIG_EXTENSION_TYPE: return createFacesConfigExtensionType();
-			case FacesConfigPackage.FACES_CONTEXT_FACTORY_TYPE: return createFacesContextFactoryType();
-			case FacesConfigPackage.FACET_EXTENSION_TYPE: return createFacetExtensionType();
-			case FacesConfigPackage.FACET_NAME_TYPE: return createFacetNameType();
-			case FacesConfigPackage.FACET_TYPE: return createFacetType();
-			case FacesConfigPackage.FACTORY_TYPE: return createFactoryType();
-			case FacesConfigPackage.FACTORY_EXTENSION_TYPE: return createFactoryExtensionType();
-			case FacesConfigPackage.FROM_ACTION_TYPE: return createFromActionType();
-			case FacesConfigPackage.FROM_OUTCOME_TYPE: return createFromOutcomeType();
-			case FacesConfigPackage.FROM_VIEW_ID_TYPE: return createFromViewIdType();
-			case FacesConfigPackage.ICON_TYPE: return createIconType();
-			case FacesConfigPackage.IF_TYPE: return createIfType();
-			case FacesConfigPackage.KEY_CLASS_TYPE: return createKeyClassType();
-			case FacesConfigPackage.KEY_TYPE: return createKeyType();
-			case FacesConfigPackage.LARGE_ICON_TYPE: return createLargeIconType();
-			case FacesConfigPackage.LIFECYCLE_FACTORY_TYPE: return createLifecycleFactoryType();
-			case FacesConfigPackage.LIFECYCLE_TYPE: return createLifecycleType();
-			case FacesConfigPackage.LIFECYCLE_EXTENSION_TYPE: return createLifecycleExtensionType();
-			case FacesConfigPackage.LIST_ENTRIES_TYPE: return createListEntriesType();
-			case FacesConfigPackage.LOCALE_CONFIG_TYPE: return createLocaleConfigType();
-			case FacesConfigPackage.MANAGED_BEAN_CLASS_TYPE: return createManagedBeanClassType();
-			case FacesConfigPackage.MANAGED_BEAN_NAME_TYPE: return createManagedBeanNameType();
-			case FacesConfigPackage.MANAGED_BEAN_SCOPE_TYPE: return createManagedBeanScopeType();
-			case FacesConfigPackage.MANAGED_BEAN_TYPE: return createManagedBeanType();
-			case FacesConfigPackage.MANAGED_BEAN_EXTENSION_TYPE: return createManagedBeanExtensionType();
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE: return createManagedPropertyType();
-			case FacesConfigPackage.MAP_ENTRIES_TYPE: return createMapEntriesType();
-			case FacesConfigPackage.MAP_ENTRY_TYPE: return createMapEntryType();
-			case FacesConfigPackage.MESSAGE_BUNDLE_TYPE: return createMessageBundleType();
-			case FacesConfigPackage.NAME_TYPE: return createNameType();
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE: return createNavigationCaseType();
-			case FacesConfigPackage.NAVIGATION_HANDLER_TYPE: return createNavigationHandlerType();
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE: return createNavigationRuleType();
-			case FacesConfigPackage.NAVIGATION_RULE_EXTENSION_TYPE: return createNavigationRuleExtensionType();
-			case FacesConfigPackage.NULL_VALUE_TYPE: return createNullValueType();
-			case FacesConfigPackage.ORDERING_TYPE: return createOrderingType();
-			case FacesConfigPackage.ORDERING_ORDERING_TYPE: return createOrderingOrderingType();
-			case FacesConfigPackage.ORDERING_OTHERS_TYPE: return createOrderingOthersType();
-			case FacesConfigPackage.PARTIAL_VIEW_CONTEXT_FACTORY_TYPE: return createPartialViewContextFactoryType();
-			case FacesConfigPackage.PHASE_LISTENER_TYPE: return createPhaseListenerType();
-			case FacesConfigPackage.PROPERTY_CLASS_TYPE: return createPropertyClassType();
-			case FacesConfigPackage.PROPERTY_EXTENSION_TYPE: return createPropertyExtensionType();
-			case FacesConfigPackage.PROPERTY_NAME_TYPE: return createPropertyNameType();
-			case FacesConfigPackage.PROPERTY_RESOLVER_TYPE: return createPropertyResolverType();
-			case FacesConfigPackage.PROPERTY_TYPE: return createPropertyType();
-			case FacesConfigPackage.REDIRECT_TYPE: return createRedirectType();
-			case FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE: return createRedirectViewParamType();
-			case FacesConfigPackage.REFERENCED_BEAN_CLASS_TYPE: return createReferencedBeanClassType();
-			case FacesConfigPackage.REFERENCED_BEAN_NAME_TYPE: return createReferencedBeanNameType();
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE: return createReferencedBeanType();
-			case FacesConfigPackage.RENDERER_CLASS_TYPE: return createRendererClassType();
-			case FacesConfigPackage.RENDERER_EXTENSION_TYPE: return createRendererExtensionType();
-			case FacesConfigPackage.RENDERER_TYPE: return createRendererType();
-			case FacesConfigPackage.RENDERER_TYPE_TYPE: return createRendererTypeType();
-			case FacesConfigPackage.RENDER_KIT_CLASS_TYPE: return createRenderKitClassType();
-			case FacesConfigPackage.RENDER_KIT_FACTORY_TYPE: return createRenderKitFactoryType();
-			case FacesConfigPackage.RENDER_KIT_ID_TYPE: return createRenderKitIdType();
-			case FacesConfigPackage.RENDER_KIT_TYPE: return createRenderKitType();
-			case FacesConfigPackage.RENDER_KIT_EXTENSION_TYPE: return createRenderKitExtensionType();
-			case FacesConfigPackage.RESOURCE_HANDLER_TYPE: return createResourceHandlerType();
-			case FacesConfigPackage.SMALL_ICON_TYPE: return createSmallIconType();
-			case FacesConfigPackage.SOURCE_CLASS_TYPE: return createSourceClassType();
-			case FacesConfigPackage.STATE_MANAGER_TYPE: return createStateManagerType();
-			case FacesConfigPackage.SUGGESTED_VALUE_TYPE: return createSuggestedValueType();
-			case FacesConfigPackage.SUPPORTED_LOCALE_TYPE: return createSupportedLocaleType();
-			case FacesConfigPackage.SYSTEM_EVENT_CLASS_TYPE: return createSystemEventClassType();
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_CLASS_TYPE: return createSystemEventListenerClassType();
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE: return createSystemEventListenerType();
-			case FacesConfigPackage.TAG_HANDLER_DELEGATE_FACTORY_TYPE: return createTagHandlerDelegateFactoryType();
-			case FacesConfigPackage.TO_VIEW_ID_TYPE: return createToViewIdType();
-			case FacesConfigPackage.VALIDATOR_CLASS_TYPE: return createValidatorClassType();
-			case FacesConfigPackage.VALIDATOR_ID_TYPE: return createValidatorIdType();
-			case FacesConfigPackage.VALIDATOR_TYPE: return createValidatorType();
-			case FacesConfigPackage.VALIDATOR_EXTENSION_TYPE: return createValidatorExtensionType();
-			case FacesConfigPackage.VALUE_CLASS_TYPE: return createValueClassType();
-			case FacesConfigPackage.VALUE_TYPE: return createValueType();
-			case FacesConfigPackage.VARIABLE_RESOLVER_TYPE: return createVariableResolverType();
-			case FacesConfigPackage.VIEW_HANDLER_TYPE: return createViewHandlerType();
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE: return createResourceBundleType();
-			case FacesConfigPackage.BASE_NAME_TYPE: return createBaseNameType();
-			case FacesConfigPackage.VAR_TYPE: return createVarType();
-			case FacesConfigPackage.VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE: return createViewDeclarationLanguageFactoryType();
-			case FacesConfigPackage.VISIT_CONTEXT_FACTORY_TYPE: return createVisitContextFactoryType();
-			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
-	 */
-	public AbsoluteOrderingType createAbsoluteOrderingType() {
-		AbsoluteOrderingTypeImpl absoluteOrderingType = new AbsoluteOrderingTypeImpl();
-		return absoluteOrderingType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ActionListenerType createActionListenerType() {
-		ActionListenerTypeImpl actionListenerType = new ActionListenerTypeImpl();
-		return actionListenerType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ApplicationFactoryType createApplicationFactoryType() {
-		ApplicationFactoryTypeImpl applicationFactoryType = new ApplicationFactoryTypeImpl();
-		return applicationFactoryType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ApplicationType createApplicationType() {
-		ApplicationTypeImpl applicationType = new ApplicationTypeImpl();
-		return applicationType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public AttributeClassType createAttributeClassType() {
-		AttributeClassTypeImpl attributeClassType = new AttributeClassTypeImpl();
-		return attributeClassType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public AttributeExtensionType createAttributeExtensionType() {
-		AttributeExtensionTypeImpl attributeExtensionType = new AttributeExtensionTypeImpl();
-		return attributeExtensionType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public AttributeNameType createAttributeNameType() {
-		AttributeNameTypeImpl attributeNameType = new AttributeNameTypeImpl();
-		return attributeNameType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public AttributeType createAttributeType() {
-		AttributeTypeImpl attributeType = new AttributeTypeImpl();
-		return attributeType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public BehaviorClassType createBehaviorClassType() {
-		BehaviorClassTypeImpl behaviorClassType = new BehaviorClassTypeImpl();
-		return behaviorClassType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public BehaviorIdType createBehaviorIdType() {
-		BehaviorIdTypeImpl behaviorIdType = new BehaviorIdTypeImpl();
-		return behaviorIdType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public BehaviorType createBehaviorType() {
-		BehaviorTypeImpl behaviorType = new BehaviorTypeImpl();
-		return behaviorType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public BehaviorExtensionType createBehaviorExtensionType() {
-		BehaviorExtensionTypeImpl behaviorExtensionType = new BehaviorExtensionTypeImpl();
-		return behaviorExtensionType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ClientBehaviorRendererClassType createClientBehaviorRendererClassType() {
-		ClientBehaviorRendererClassTypeImpl clientBehaviorRendererClassType = new ClientBehaviorRendererClassTypeImpl();
-		return clientBehaviorRendererClassType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ClientBehaviorRendererType createClientBehaviorRendererType() {
-		ClientBehaviorRendererTypeImpl clientBehaviorRendererType = new ClientBehaviorRendererTypeImpl();
-		return clientBehaviorRendererType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ClientBehaviorRendererTypeType createClientBehaviorRendererTypeType() {
-		ClientBehaviorRendererTypeTypeImpl clientBehaviorRendererTypeType = new ClientBehaviorRendererTypeTypeImpl();
-		return clientBehaviorRendererTypeType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ComponentClassType createComponentClassType() {
-		ComponentClassTypeImpl componentClassType = new ComponentClassTypeImpl();
-		return componentClassType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ComponentExtensionType createComponentExtensionType() {
-		ComponentExtensionTypeImpl componentExtensionType = new ComponentExtensionTypeImpl();
-		return componentExtensionType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ComponentFamilyType createComponentFamilyType() {
-		ComponentFamilyTypeImpl componentFamilyType = new ComponentFamilyTypeImpl();
-		return componentFamilyType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ComponentType createComponentType() {
-		ComponentTypeImpl componentType = new ComponentTypeImpl();
-		return componentType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ComponentTypeType createComponentTypeType() {
-		ComponentTypeTypeImpl componentTypeType = new ComponentTypeTypeImpl();
-		return componentTypeType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConverterClassType createConverterClassType() {
-		ConverterClassTypeImpl converterClassType = new ConverterClassTypeImpl();
-		return converterClassType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConverterForClassType createConverterForClassType() {
-		ConverterForClassTypeImpl converterForClassType = new ConverterForClassTypeImpl();
-		return converterForClassType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConverterIdType createConverterIdType() {
-		ConverterIdTypeImpl converterIdType = new ConverterIdTypeImpl();
-		return converterIdType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConverterType createConverterType() {
-		ConverterTypeImpl converterType = new ConverterTypeImpl();
-		return converterType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DefaultLocaleType createDefaultLocaleType() {
-		DefaultLocaleTypeImpl defaultLocaleType = new DefaultLocaleTypeImpl();
-		return defaultLocaleType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DefaultRenderKitIdType createDefaultRenderKitIdType() {
-		DefaultRenderKitIdTypeImpl defaultRenderKitIdType = new DefaultRenderKitIdTypeImpl();
-		return defaultRenderKitIdType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DefaultValidatorsType createDefaultValidatorsType() {
-		DefaultValidatorsTypeImpl defaultValidatorsType = new DefaultValidatorsTypeImpl();
-		return defaultValidatorsType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DefaultValueType createDefaultValueType() {
-		DefaultValueTypeImpl defaultValueType = new DefaultValueTypeImpl();
-		return defaultValueType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DescriptionType createDescriptionType() {
-		DescriptionTypeImpl descriptionType = new DescriptionTypeImpl();
-		return descriptionType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DisplayNameType createDisplayNameType() {
-		DisplayNameTypeImpl displayNameType = new DisplayNameTypeImpl();
-		return displayNameType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DocumentRoot createDocumentRoot() {
-		DocumentRootImpl documentRoot = new DocumentRootImpl();
-		return documentRoot;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public DynamicAttribute createDynamicAttribute() {
-		DynamicAttributeImpl dynamicAttribute = new DynamicAttributeImpl();
-		return dynamicAttribute;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public DynamicElement createDynamicElement() {
-		DynamicElementImpl dynamicElement = new DynamicElementImpl();
-		return dynamicElement;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ELResolverType createELResolverType() {
-		ELResolverTypeImpl elResolverType = new ELResolverTypeImpl();
-		return elResolverType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ExceptionHandlerFactoryType createExceptionHandlerFactoryType() {
-		ExceptionHandlerFactoryTypeImpl exceptionHandlerFactoryType = new ExceptionHandlerFactoryTypeImpl();
-		return exceptionHandlerFactoryType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ExternalContextFactoryType createExternalContextFactoryType() {
-		ExternalContextFactoryTypeImpl externalContextFactoryType = new ExternalContextFactoryTypeImpl();
-		return externalContextFactoryType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FacesConfigType createFacesConfigType() {
-		FacesConfigTypeImpl facesConfigType = new FacesConfigTypeImpl();
-		return facesConfigType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FacesContextFactoryType createFacesContextFactoryType() {
-		FacesContextFactoryTypeImpl facesContextFactoryType = new FacesContextFactoryTypeImpl();
-		return facesContextFactoryType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FacetExtensionType createFacetExtensionType() {
-		FacetExtensionTypeImpl facetExtensionType = new FacetExtensionTypeImpl();
-		return facetExtensionType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FacetNameType createFacetNameType() {
-		FacetNameTypeImpl facetNameType = new FacetNameTypeImpl();
-		return facetNameType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FacetType createFacetType() {
-		FacetTypeImpl facetType = new FacetTypeImpl();
-		return facetType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FactoryType createFactoryType() {
-		FactoryTypeImpl factoryType = new FactoryTypeImpl();
-		return factoryType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FromActionType createFromActionType() {
-		FromActionTypeImpl fromActionType = new FromActionTypeImpl();
-		return fromActionType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FromOutcomeType createFromOutcomeType() {
-		FromOutcomeTypeImpl fromOutcomeType = new FromOutcomeTypeImpl();
-		return fromOutcomeType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FromViewIdType createFromViewIdType() {
-		FromViewIdTypeImpl fromViewIdType = new FromViewIdTypeImpl();
-		return fromViewIdType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public IconType createIconType() {
-		IconTypeImpl iconType = new IconTypeImpl();
-		return iconType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public IfType createIfType() {
-		IfTypeImpl ifType = new IfTypeImpl();
-		return ifType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public KeyClassType createKeyClassType() {
-		KeyClassTypeImpl keyClassType = new KeyClassTypeImpl();
-		return keyClassType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public KeyType createKeyType() {
-		KeyTypeImpl keyType = new KeyTypeImpl();
-		return keyType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public LargeIconType createLargeIconType() {
-		LargeIconTypeImpl largeIconType = new LargeIconTypeImpl();
-		return largeIconType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public LifecycleFactoryType createLifecycleFactoryType() {
-		LifecycleFactoryTypeImpl lifecycleFactoryType = new LifecycleFactoryTypeImpl();
-		return lifecycleFactoryType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public LifecycleType createLifecycleType() {
-		LifecycleTypeImpl lifecycleType = new LifecycleTypeImpl();
-		return lifecycleType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ListEntriesType createListEntriesType() {
-		ListEntriesTypeImpl listEntriesType = new ListEntriesTypeImpl();
-		return listEntriesType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public LocaleConfigType createLocaleConfigType() {
-		LocaleConfigTypeImpl localeConfigType = new LocaleConfigTypeImpl();
-		return localeConfigType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ManagedBeanClassType createManagedBeanClassType() {
-		ManagedBeanClassTypeImpl managedBeanClassType = new ManagedBeanClassTypeImpl();
-		return managedBeanClassType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ManagedBeanNameType createManagedBeanNameType() {
-		ManagedBeanNameTypeImpl managedBeanNameType = new ManagedBeanNameTypeImpl();
-		return managedBeanNameType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ManagedBeanScopeType createManagedBeanScopeType() {
-		ManagedBeanScopeTypeImpl managedBeanScopeType = new ManagedBeanScopeTypeImpl();
-		return managedBeanScopeType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ManagedBeanType createManagedBeanType() {
-		ManagedBeanTypeImpl managedBeanType = new ManagedBeanTypeImpl();
-		return managedBeanType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ManagedPropertyType createManagedPropertyType() {
-		ManagedPropertyTypeImpl managedPropertyType = new ManagedPropertyTypeImpl();
-		return managedPropertyType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public MapEntriesType createMapEntriesType() {
-		MapEntriesTypeImpl mapEntriesType = new MapEntriesTypeImpl();
-		return mapEntriesType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public MapEntryType createMapEntryType() {
-		MapEntryTypeImpl mapEntryType = new MapEntryTypeImpl();
-		return mapEntryType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public MessageBundleType createMessageBundleType() {
-		MessageBundleTypeImpl messageBundleType = new MessageBundleTypeImpl();
-		return messageBundleType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NameType createNameType() {
-		NameTypeImpl nameType = new NameTypeImpl();
-		return nameType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NavigationCaseType createNavigationCaseType() {
-		NavigationCaseTypeImpl navigationCaseType = new NavigationCaseTypeImpl();
-		return navigationCaseType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NavigationHandlerType createNavigationHandlerType() {
-		NavigationHandlerTypeImpl navigationHandlerType = new NavigationHandlerTypeImpl();
-		return navigationHandlerType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NavigationRuleType createNavigationRuleType() {
-		NavigationRuleTypeImpl navigationRuleType = new NavigationRuleTypeImpl();
-		return navigationRuleType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NullValueType createNullValueType() {
-		NullValueTypeImpl nullValueType = new NullValueTypeImpl();
-		return nullValueType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public OrderingType createOrderingType() {
-		OrderingTypeImpl orderingType = new OrderingTypeImpl();
-		return orderingType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public OrderingOrderingType createOrderingOrderingType() {
-		OrderingOrderingTypeImpl orderingOrderingType = new OrderingOrderingTypeImpl();
-		return orderingOrderingType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public OrderingOthersType createOrderingOthersType() {
-		OrderingOthersTypeImpl orderingOthersType = new OrderingOthersTypeImpl();
-		return orderingOthersType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PartialViewContextFactoryType createPartialViewContextFactoryType() {
-		PartialViewContextFactoryTypeImpl partialViewContextFactoryType = new PartialViewContextFactoryTypeImpl();
-		return partialViewContextFactoryType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PhaseListenerType createPhaseListenerType() {
-		PhaseListenerTypeImpl phaseListenerType = new PhaseListenerTypeImpl();
-		return phaseListenerType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PropertyClassType createPropertyClassType() {
-		PropertyClassTypeImpl propertyClassType = new PropertyClassTypeImpl();
-		return propertyClassType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PropertyExtensionType createPropertyExtensionType() {
-		PropertyExtensionTypeImpl propertyExtensionType = new PropertyExtensionTypeImpl();
-		return propertyExtensionType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PropertyNameType createPropertyNameType() {
-		PropertyNameTypeImpl propertyNameType = new PropertyNameTypeImpl();
-		return propertyNameType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PropertyResolverType createPropertyResolverType() {
-		PropertyResolverTypeImpl propertyResolverType = new PropertyResolverTypeImpl();
-		return propertyResolverType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PropertyType createPropertyType() {
-		PropertyTypeImpl propertyType = new PropertyTypeImpl();
-		return propertyType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RedirectType createRedirectType() {
-		RedirectTypeImpl redirectType = new RedirectTypeImpl();
-		return redirectType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RedirectViewParamType createRedirectViewParamType() {
-		RedirectViewParamTypeImpl redirectViewParamType = new RedirectViewParamTypeImpl();
-		return redirectViewParamType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ReferencedBeanClassType createReferencedBeanClassType() {
-		ReferencedBeanClassTypeImpl referencedBeanClassType = new ReferencedBeanClassTypeImpl();
-		return referencedBeanClassType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ReferencedBeanNameType createReferencedBeanNameType() {
-		ReferencedBeanNameTypeImpl referencedBeanNameType = new ReferencedBeanNameTypeImpl();
-		return referencedBeanNameType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ReferencedBeanType createReferencedBeanType() {
-		ReferencedBeanTypeImpl referencedBeanType = new ReferencedBeanTypeImpl();
-		return referencedBeanType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RendererClassType createRendererClassType() {
-		RendererClassTypeImpl rendererClassType = new RendererClassTypeImpl();
-		return rendererClassType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RendererExtensionType createRendererExtensionType() {
-		RendererExtensionTypeImpl rendererExtensionType = new RendererExtensionTypeImpl();
-		return rendererExtensionType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RendererType createRendererType() {
-		RendererTypeImpl rendererType = new RendererTypeImpl();
-		return rendererType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RendererTypeType createRendererTypeType() {
-		RendererTypeTypeImpl rendererTypeType = new RendererTypeTypeImpl();
-		return rendererTypeType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RenderKitClassType createRenderKitClassType() {
-		RenderKitClassTypeImpl renderKitClassType = new RenderKitClassTypeImpl();
-		return renderKitClassType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RenderKitFactoryType createRenderKitFactoryType() {
-		RenderKitFactoryTypeImpl renderKitFactoryType = new RenderKitFactoryTypeImpl();
-		return renderKitFactoryType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RenderKitIdType createRenderKitIdType() {
-		RenderKitIdTypeImpl renderKitIdType = new RenderKitIdTypeImpl();
-		return renderKitIdType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RenderKitType createRenderKitType() {
-		RenderKitTypeImpl renderKitType = new RenderKitTypeImpl();
-		return renderKitType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SmallIconType createSmallIconType() {
-		SmallIconTypeImpl smallIconType = new SmallIconTypeImpl();
-		return smallIconType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SourceClassType createSourceClassType() {
-		SourceClassTypeImpl sourceClassType = new SourceClassTypeImpl();
-		return sourceClassType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public StateManagerType createStateManagerType() {
-		StateManagerTypeImpl stateManagerType = new StateManagerTypeImpl();
-		return stateManagerType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SuggestedValueType createSuggestedValueType() {
-		SuggestedValueTypeImpl suggestedValueType = new SuggestedValueTypeImpl();
-		return suggestedValueType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SupportedLocaleType createSupportedLocaleType() {
-		SupportedLocaleTypeImpl supportedLocaleType = new SupportedLocaleTypeImpl();
-		return supportedLocaleType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SystemEventClassType createSystemEventClassType() {
-		SystemEventClassTypeImpl systemEventClassType = new SystemEventClassTypeImpl();
-		return systemEventClassType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SystemEventListenerClassType createSystemEventListenerClassType() {
-		SystemEventListenerClassTypeImpl systemEventListenerClassType = new SystemEventListenerClassTypeImpl();
-		return systemEventListenerClassType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SystemEventListenerType createSystemEventListenerType() {
-		SystemEventListenerTypeImpl systemEventListenerType = new SystemEventListenerTypeImpl();
-		return systemEventListenerType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public TagHandlerDelegateFactoryType createTagHandlerDelegateFactoryType() {
-		TagHandlerDelegateFactoryTypeImpl tagHandlerDelegateFactoryType = new TagHandlerDelegateFactoryTypeImpl();
-		return tagHandlerDelegateFactoryType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ToViewIdType createToViewIdType() {
-		ToViewIdTypeImpl toViewIdType = new ToViewIdTypeImpl();
-		return toViewIdType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValidatorClassType createValidatorClassType() {
-		ValidatorClassTypeImpl validatorClassType = new ValidatorClassTypeImpl();
-		return validatorClassType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValidatorIdType createValidatorIdType() {
-		ValidatorIdTypeImpl validatorIdType = new ValidatorIdTypeImpl();
-		return validatorIdType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValidatorType createValidatorType() {
-		ValidatorTypeImpl validatorType = new ValidatorTypeImpl();
-		return validatorType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValueClassType createValueClassType() {
-		ValueClassTypeImpl valueClassType = new ValueClassTypeImpl();
-		return valueClassType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValueType createValueType() {
-		ValueTypeImpl valueType = new ValueTypeImpl();
-		return valueType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public VariableResolverType createVariableResolverType() {
-		VariableResolverTypeImpl variableResolverType = new VariableResolverTypeImpl();
-		return variableResolverType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ViewHandlerType createViewHandlerType() {
-		ViewHandlerTypeImpl viewHandlerType = new ViewHandlerTypeImpl();
-		return viewHandlerType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ApplicationExtensionType createApplicationExtensionType() {
-		ApplicationExtensionTypeImpl applicationExtensionType = new ApplicationExtensionTypeImpl();
-		return applicationExtensionType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ResourceBundleType createResourceBundleType() {
-		ResourceBundleTypeImpl resourceBundleType = new ResourceBundleTypeImpl();
-		return resourceBundleType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public BaseNameType createBaseNameType() {
-		BaseNameTypeImpl baseNameType = new BaseNameTypeImpl();
-		return baseNameType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public VarType createVarType() {
-		VarTypeImpl varType = new VarTypeImpl();
-		return varType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ViewDeclarationLanguageFactoryType createViewDeclarationLanguageFactoryType() {
-		ViewDeclarationLanguageFactoryTypeImpl viewDeclarationLanguageFactoryType = new ViewDeclarationLanguageFactoryTypeImpl();
-		return viewDeclarationLanguageFactoryType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public VisitContextFactoryType createVisitContextFactoryType() {
-		VisitContextFactoryTypeImpl visitContextFactoryType = new VisitContextFactoryTypeImpl();
-		return visitContextFactoryType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public RenderKitExtensionType createRenderKitExtensionType() {
-		RenderKitExtensionTypeImpl renderKitExtensionType = new RenderKitExtensionTypeImpl();
-		return renderKitExtensionType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ResourceHandlerType createResourceHandlerType() {
-		ResourceHandlerTypeImpl resourceHandlerType = new ResourceHandlerTypeImpl();
-		return resourceHandlerType;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NavigationRuleExtensionType createNavigationRuleExtensionType() {
-		NavigationRuleExtensionTypeImpl navigationRuleExtensionType = new NavigationRuleExtensionTypeImpl();
-		return navigationRuleExtensionType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ValidatorExtensionType createValidatorExtensionType() {
-		ValidatorExtensionTypeImpl validatorExtensionType = new ValidatorExtensionTypeImpl();
-		return validatorExtensionType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public FacesConfigExtensionType createFacesConfigExtensionType() {
-		FacesConfigExtensionTypeImpl facesConfigExtensionType = new FacesConfigExtensionTypeImpl();
-		return facesConfigExtensionType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public FactoryExtensionType createFactoryExtensionType() {
-		FactoryExtensionTypeImpl factoryExtensionType = new FactoryExtensionTypeImpl();
-		return factoryExtensionType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public LifecycleExtensionType createLifecycleExtensionType() {
-		LifecycleExtensionTypeImpl lifecycleExtensionType = new LifecycleExtensionTypeImpl();
-		return lifecycleExtensionType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ManagedBeanExtensionType createManagedBeanExtensionType() {
-		ManagedBeanExtensionTypeImpl managedBeanExtensionType = new ManagedBeanExtensionTypeImpl();
-		return managedBeanExtensionType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public ConverterExtensionType createConverterExtensionType() {
-		ConverterExtensionTypeImpl converterExtensionType = new ConverterExtensionTypeImpl();
-		return converterExtensionType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FacesConfigPackage getFacesConfigPackage() {
-		return (FacesConfigPackage)getEPackage();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @return the package 
-	 * <!-- end-user-doc -->
-	 * @deprecated
-	 * @generated
-	 */
-	public static FacesConfigPackage getPackage() {
-		return FacesConfigPackage.eINSTANCE;
-	}
-
-} //FacesConfigFactoryImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacesConfigPackageImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacesConfigPackageImpl.java
deleted file mode 100644
index 3a9ae60..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacesConfigPackageImpl.java
+++ /dev/null
@@ -1,12418 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.ecore.EAttribute;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.EReference;
-import org.eclipse.emf.ecore.impl.EPackageImpl;
-import org.eclipse.emf.ecore.xml.type.XMLTypePackage;
-import org.eclipse.jst.jsf.facesconfig.emf.*;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model <b>Package</b>.
- * <!-- end-user-doc -->
- * @generated
- */
-@SuppressWarnings("nls")
-public class FacesConfigPackageImpl extends EPackageImpl implements FacesConfigPackage {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; 
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass absoluteOrderingTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass actionListenerTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass applicationFactoryTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass applicationTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass attributeClassTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass attributeExtensionTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass attributeNameTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass attributeTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass behaviorClassTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass behaviorIdTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass behaviorTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass behaviorExtensionTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass clientBehaviorRendererClassTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass clientBehaviorRendererTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass clientBehaviorRendererTypeTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass componentClassTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass componentExtensionTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass componentFamilyTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass componentTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass componentTypeTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass converterClassTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass converterForClassTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass converterIdTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass converterTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass defaultLocaleTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass defaultRenderKitIdTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass defaultValidatorsTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass defaultValueTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass descriptionTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass displayNameTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass documentRootEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    private EClass dynamicAttributeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    private EClass dynamicElementEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    private EClass elResolverTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass exceptionHandlerFactoryTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass facesConfigTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass facesContextFactoryTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass facetExtensionTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass facetNameTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass facetTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass factoryTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass fromActionTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass fromOutcomeTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass fromViewIdTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass iconTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass ifTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass keyClassTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass keyTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass largeIconTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass lifecycleFactoryTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass lifecycleTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass listEntriesTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass localeConfigTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass managedBeanClassTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass managedBeanNameTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass managedBeanScopeTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass managedBeanTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass managedPropertyTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass mapEntriesTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass mapEntryTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass messageBundleTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass nameTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass navigationCaseTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass navigationHandlerTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass navigationRuleTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass nullValueTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass orderingTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass orderingOrderingTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass orderingOthersTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass partialViewContextFactoryTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass phaseListenerTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass propertyClassTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass propertyExtensionTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass propertyNameTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass propertyResolverTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass propertyTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass redirectTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass redirectViewParamTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass referencedBeanClassTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass referencedBeanNameTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass referencedBeanTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass rendererClassTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass rendererExtensionTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass rendererTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass rendererTypeTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass renderKitClassTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass renderKitFactoryTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass renderKitIdTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass renderKitTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass smallIconTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass sourceClassTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass stateManagerTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass suggestedValueTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass supportedLocaleTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass systemEventClassTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass systemEventListenerClassTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass systemEventListenerTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass tagHandlerDelegateFactoryTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass toViewIdTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass validatorClassTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass validatorIdTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass validatorTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass valueClassTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass valueTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass variableResolverTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass viewHandlerTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    private EClass resourceBundleTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    private EClass baseNameTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    private EClass varTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass viewDeclarationLanguageFactoryTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass visitContextFactoryTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    private EClass renderKitExtensionTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass resourceHandlerTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    private EClass navigationRuleExtensionTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    private EClass validatorExtensionTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    private EClass facesConfigExtensionTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    private EClass factoryExtensionTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    private EClass lifecycleExtensionTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    private EClass managedBeanExtensionTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    private EClass converterExtensionTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    private EClass extensionTypeEClass = null;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass externalContextFactoryTypeEClass = null;
-
-				/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    private EClass applicationExtensionTypeEClass = 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.jst.jsf.facesconfig.emf.FacesConfigPackage#eNS_URI
-	 * @see #init()
-	 * @generated
-	 */
-	private FacesConfigPackageImpl() {
-		super(eNS_URI, FacesConfigFactory.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 FacesConfigPackage#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 -->
-     * @return the package 
-	 * <!-- end-user-doc -->
-	 * @see #eNS_URI
-	 * @see #createPackageContents()
-	 * @see #initializePackageContents()
-	 * @generated
-	 */
-	public static FacesConfigPackage init() {
-		if (isInited) return (FacesConfigPackage)EPackage.Registry.INSTANCE.getEPackage(FacesConfigPackage.eNS_URI);
-
-		// Obtain or create and register package
-		FacesConfigPackageImpl theFacesConfigPackage = (FacesConfigPackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof FacesConfigPackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new FacesConfigPackageImpl());
-
-		isInited = true;
-
-		// Initialize simple dependencies
-		XMLTypePackage.eINSTANCE.eClass();
-
-		// Create package meta-data objects
-		theFacesConfigPackage.createPackageContents();
-
-		// Initialize created meta-data
-		theFacesConfigPackage.initializePackageContents();
-
-		// Mark meta-data to indicate it can't be changed
-		theFacesConfigPackage.freeze();
-
-  
-		// Update the registry and return the package
-		EPackage.Registry.INSTANCE.put(FacesConfigPackage.eNS_URI, theFacesConfigPackage);
-		return theFacesConfigPackage;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getAbsoluteOrderingType() {
-		return absoluteOrderingTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getAbsoluteOrderingType_Name() {
-		return (EReference)absoluteOrderingTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getAbsoluteOrderingType_Others() {
-		return (EReference)absoluteOrderingTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getActionListenerType() {
-		return actionListenerTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getActionListenerType_TextContent() {
-		return (EAttribute)actionListenerTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getActionListenerType_Id() {
-		return (EAttribute)actionListenerTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getApplicationFactoryType() {
-		return applicationFactoryTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getApplicationFactoryType_TextContent() {
-		return (EAttribute)applicationFactoryTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getApplicationFactoryType_Id() {
-		return (EAttribute)applicationFactoryTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getApplicationType() {
-		return applicationTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getApplicationType_ActionListener() {
-		return (EReference)applicationTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getApplicationType_DefaultRenderKitId() {
-		return (EReference)applicationTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getApplicationType_MessageBundle() {
-		return (EReference)applicationTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getApplicationType_NavigationHandler() {
-		return (EReference)applicationTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getApplicationType_ViewHandler() {
-		return (EReference)applicationTypeEClass.getEStructuralFeatures().get(4);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getApplicationType_StateManager() {
-		return (EReference)applicationTypeEClass.getEStructuralFeatures().get(5);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getApplicationType_PropertyResolver() {
-		return (EReference)applicationTypeEClass.getEStructuralFeatures().get(7);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getApplicationType_VariableResolver() {
-		return (EReference)applicationTypeEClass.getEStructuralFeatures().get(8);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getApplicationType_ResourceHandler() {
-		return (EReference)applicationTypeEClass.getEStructuralFeatures().get(9);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getApplicationType_SystemEventListener() {
-		return (EReference)applicationTypeEClass.getEStructuralFeatures().get(10);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getApplicationType_LocaleConfig() {
-		return (EReference)applicationTypeEClass.getEStructuralFeatures().get(11);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getApplicationType_Id() {
-		return (EAttribute)applicationTypeEClass.getEStructuralFeatures().get(15);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EReference getApplicationType_ELResolver() {
-		return (EReference)applicationTypeEClass.getEStructuralFeatures().get(6);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EReference getApplicationType_ResourceBundle() {
-		return (EReference)applicationTypeEClass.getEStructuralFeatures().get(12);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EReference getApplicationType_ApplicationExtension() {
-		return (EReference)applicationTypeEClass.getEStructuralFeatures().get(13);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getApplicationType_DefaultValidators() {
-		return (EReference)applicationTypeEClass.getEStructuralFeatures().get(14);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getAttributeClassType() {
-		return attributeClassTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getAttributeClassType_TextContent() {
-		return (EAttribute)attributeClassTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getAttributeClassType_Id() {
-		return (EAttribute)attributeClassTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getAttributeExtensionType() {
-		return attributeExtensionTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getAttributeNameType() {
-		return attributeNameTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getAttributeNameType_TextContent() {
-		return (EAttribute)attributeNameTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getAttributeNameType_Id() {
-		return (EAttribute)attributeNameTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getAttributeType() {
-		return attributeTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getAttributeType_Description() {
-		return (EReference)attributeTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getAttributeType_DisplayName() {
-		return (EReference)attributeTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getAttributeType_Icon() {
-		return (EReference)attributeTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getAttributeType_AttributeName() {
-		return (EReference)attributeTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getAttributeType_AttributeClass() {
-		return (EReference)attributeTypeEClass.getEStructuralFeatures().get(4);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getAttributeType_DefaultValue() {
-		return (EReference)attributeTypeEClass.getEStructuralFeatures().get(5);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getAttributeType_SuggestedValue() {
-		return (EReference)attributeTypeEClass.getEStructuralFeatures().get(6);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getAttributeType_AttributeExtension() {
-		return (EReference)attributeTypeEClass.getEStructuralFeatures().get(7);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getAttributeType_Id() {
-		return (EAttribute)attributeTypeEClass.getEStructuralFeatures().get(8);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getBehaviorClassType() {
-		return behaviorClassTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getBehaviorClassType_TextContent() {
-		return (EAttribute)behaviorClassTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getBehaviorClassType_Id() {
-		return (EAttribute)behaviorClassTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getBehaviorIdType() {
-		return behaviorIdTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getBehaviorIdType_TextContent() {
-		return (EAttribute)behaviorIdTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getBehaviorIdType_Id() {
-		return (EAttribute)behaviorIdTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getBehaviorType() {
-		return behaviorTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getBehaviorType_Description() {
-		return (EReference)behaviorTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getBehaviorType_DisplayName() {
-		return (EReference)behaviorTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getBehaviorType_Icon() {
-		return (EReference)behaviorTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getBehaviorType_BehaviorId() {
-		return (EReference)behaviorTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getBehaviorType_BehaviorClass() {
-		return (EReference)behaviorTypeEClass.getEStructuralFeatures().get(4);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getBehaviorType_Attribute() {
-		return (EReference)behaviorTypeEClass.getEStructuralFeatures().get(5);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getBehaviorType_Property() {
-		return (EReference)behaviorTypeEClass.getEStructuralFeatures().get(6);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getBehaviorType_BehaviorExtension() {
-		return (EReference)behaviorTypeEClass.getEStructuralFeatures().get(7);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getBehaviorExtensionType() {
-		return behaviorExtensionTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getClientBehaviorRendererClassType() {
-		return clientBehaviorRendererClassTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getClientBehaviorRendererClassType_TextContent() {
-		return (EAttribute)clientBehaviorRendererClassTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getClientBehaviorRendererClassType_Id() {
-		return (EAttribute)clientBehaviorRendererClassTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getClientBehaviorRendererType() {
-		return clientBehaviorRendererTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getClientBehaviorRendererType_ClientBehaviorRendererType() {
-		return (EReference)clientBehaviorRendererTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getClientBehaviorRendererType_ClientBehaviorRendererClass() {
-		return (EReference)clientBehaviorRendererTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getClientBehaviorRendererTypeType() {
-		return clientBehaviorRendererTypeTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getClientBehaviorRendererTypeType_TextContent() {
-		return (EAttribute)clientBehaviorRendererTypeTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getClientBehaviorRendererTypeType_Id() {
-		return (EAttribute)clientBehaviorRendererTypeTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getComponentClassType() {
-		return componentClassTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getComponentClassType_TextContent() {
-		return (EAttribute)componentClassTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getComponentClassType_Id() {
-		return (EAttribute)componentClassTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getComponentExtensionType() {
-		return componentExtensionTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getComponentFamilyType() {
-		return componentFamilyTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getComponentFamilyType_TextContent() {
-		return (EAttribute)componentFamilyTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getComponentFamilyType_Id() {
-		return (EAttribute)componentFamilyTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getComponentType() {
-		return componentTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getComponentType_Description() {
-		return (EReference)componentTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getComponentType_DisplayName() {
-		return (EReference)componentTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getComponentType_Icon() {
-		return (EReference)componentTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getComponentType_ComponentType() {
-		return (EReference)componentTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getComponentType_ComponentClass() {
-		return (EReference)componentTypeEClass.getEStructuralFeatures().get(4);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getComponentType_Facet() {
-		return (EReference)componentTypeEClass.getEStructuralFeatures().get(5);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getComponentType_Attribute() {
-		return (EReference)componentTypeEClass.getEStructuralFeatures().get(6);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getComponentType_Property() {
-		return (EReference)componentTypeEClass.getEStructuralFeatures().get(7);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getComponentType_ComponentExtension() {
-		return (EReference)componentTypeEClass.getEStructuralFeatures().get(8);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getComponentType_Id() {
-		return (EAttribute)componentTypeEClass.getEStructuralFeatures().get(9);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getComponentTypeType() {
-		return componentTypeTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getComponentTypeType_TextContent() {
-		return (EAttribute)componentTypeTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getComponentTypeType_Id() {
-		return (EAttribute)componentTypeTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getConverterClassType() {
-		return converterClassTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getConverterClassType_TextContent() {
-		return (EAttribute)converterClassTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getConverterClassType_Id() {
-		return (EAttribute)converterClassTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getConverterForClassType() {
-		return converterForClassTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getConverterForClassType_TextContent() {
-		return (EAttribute)converterForClassTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getConverterForClassType_Id() {
-		return (EAttribute)converterForClassTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getConverterIdType() {
-		return converterIdTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getConverterIdType_TextContent() {
-		return (EAttribute)converterIdTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getConverterIdType_Id() {
-		return (EAttribute)converterIdTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getConverterType() {
-		return converterTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getConverterType_Description() {
-		return (EReference)converterTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getConverterType_DisplayName() {
-		return (EReference)converterTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getConverterType_Icon() {
-		return (EReference)converterTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getConverterType_ConverterId() {
-		return (EReference)converterTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getConverterType_ConverterForClass() {
-		return (EReference)converterTypeEClass.getEStructuralFeatures().get(4);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getConverterType_ConverterClass() {
-		return (EReference)converterTypeEClass.getEStructuralFeatures().get(5);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getConverterType_Attribute() {
-		return (EReference)converterTypeEClass.getEStructuralFeatures().get(6);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getConverterType_Property() {
-		return (EReference)converterTypeEClass.getEStructuralFeatures().get(7);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EReference getConverterType_ConverterExtension() {
-		return (EReference)converterTypeEClass.getEStructuralFeatures().get(8);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getConverterType_Id() {
-		return (EAttribute)converterTypeEClass.getEStructuralFeatures().get(9);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getDefaultLocaleType() {
-		return defaultLocaleTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getDefaultLocaleType_TextContent() {
-		return (EAttribute)defaultLocaleTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getDefaultLocaleType_Id() {
-		return (EAttribute)defaultLocaleTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getDefaultRenderKitIdType() {
-		return defaultRenderKitIdTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getDefaultRenderKitIdType_TextContent() {
-		return (EAttribute)defaultRenderKitIdTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getDefaultRenderKitIdType_Id() {
-		return (EAttribute)defaultRenderKitIdTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getDefaultValidatorsType() {
-		return defaultValidatorsTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDefaultValidatorsType_ValidatorId() {
-		return (EReference)defaultValidatorsTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getDefaultValidatorsType_Id() {
-		return (EAttribute)defaultValidatorsTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getDefaultValueType() {
-		return defaultValueTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getDefaultValueType_TextContent() {
-		return (EAttribute)defaultValueTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getDefaultValueType_Id() {
-		return (EAttribute)defaultValueTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getDescriptionType() {
-		return descriptionTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getDescriptionType_TextContent() {
-		return (EAttribute)descriptionTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getDescriptionType_Lang() {
-		return (EAttribute)descriptionTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getDescriptionType_Id() {
-		return (EAttribute)descriptionTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getDisplayNameType() {
-		return displayNameTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getDisplayNameType_TextContent() {
-		return (EAttribute)displayNameTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getDisplayNameType_Lang() {
-		return (EAttribute)displayNameTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getDisplayNameType_Id() {
-		return (EAttribute)displayNameTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getDocumentRoot() {
-		return documentRootEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getDocumentRoot_Mixed() {
-		return (EAttribute)documentRootEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_XMLNSPrefixMap() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_XSISchemaLocation() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_AbsoluteOrdering() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(3);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ActionListener() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(4);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_Application() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(5);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ApplicationFactory() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(6);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_Attribute() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(7);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_AttributeClass() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(8);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_AttributeExtension() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(9);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_AttributeName() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(10);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_Behavior() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(11);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_BehaviorClass() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(12);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_BehaviorId() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(13);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_BehaviorExtension() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(14);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_Component() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(15);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ComponentClass() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(16);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ComponentExtension() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(17);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ComponentFamily() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(18);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ComponentType() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(19);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_Converter() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(20);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ConverterClass() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(21);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ConverterForClass() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(22);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ConverterId() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(23);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_DefaultLocale() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(24);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_DefaultRenderKitId() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(25);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_DefaultValidators() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(26);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_DefaultValue() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(27);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_Description() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(28);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_DisplayName() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(29);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ExceptionHandlerFactory() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(30);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ExternalContextFactory() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(31);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_FacesConfig() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(32);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_FacesContextFactory() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(33);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_Facet() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(34);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_FacetExtension() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(35);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_FacetName() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(36);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_Factory() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(37);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_FromAction() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(38);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_FromOutcome() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(39);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_FromViewId() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(40);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_Icon() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(41);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_If() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(42);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_Key() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(43);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_KeyClass() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(44);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_LargeIcon() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(45);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_Lifecycle() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(46);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_LifecycleFactory() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(47);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ListEntries() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(48);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_LocaleConfig() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(49);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ManagedBean() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(50);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ManagedBeanClass() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(51);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ManagedBeanName() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(52);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ManagedBeanScope() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(53);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ManagedProperty() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(54);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_MapEntries() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(55);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_MapEntry() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(56);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_MessageBundle() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(57);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_Name() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(58);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_NavigationCase() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(59);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_NavigationHandler() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(60);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_NavigationRule() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(61);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_NullValue() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(62);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_Ordering() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(63);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_OrderingOrdering() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(64);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_Others() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(65);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_PartialViewContextFactory() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(66);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_PhaseListener() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(67);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_Property() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(68);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_PropertyClass() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(69);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_PropertyExtension() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(70);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_PropertyName() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(71);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_PropertyResolver() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(72);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_Redirect() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(73);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_RedirectViewParam() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(74);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ReferencedBean() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(75);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ReferencedBeanClass() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(76);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ReferencedBeanName() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(77);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_Renderer() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(78);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_RendererClass() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(79);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_RendererExtension() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(80);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_RendererType() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(81);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_RenderKit() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(82);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_RenderKitClass() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(83);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_RenderKitFactory() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(84);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_RenderKitId() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(85);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ResourceHandler() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(86);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_SmallIcon() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(87);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_SourceClass() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(88);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_StateManager() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(89);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_SuggestedValue() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(90);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_SupportedLocale() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(91);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_SystemEventClass() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(92);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_SystemEventListener() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(93);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_SystemEventListenerClass() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(94);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_TagHandlerDelegateFactory() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(95);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ToViewId() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(96);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_Validator() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(97);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ValidatorClass() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(98);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ValidatorId() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(99);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_Value() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(100);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ValueClass() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(101);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_VariableResolver() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(102);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ViewDeclarationLanguageFactory() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(103);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_ViewHandler() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(104);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getDocumentRoot_VisitContextFactory() {
-		return (EReference)documentRootEClass.getEStructuralFeatures().get(105);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EClass getDynamicAttribute() {
-		return dynamicAttributeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EAttribute getDynamicAttribute_Name() {
-		return (EAttribute)dynamicAttributeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EAttribute getDynamicAttribute_Value() {
-		return (EAttribute)dynamicAttributeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EClass getDynamicElement() {
-		return dynamicElementEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EReference getDynamicElement_ChildNodes() {
-		return (EReference)dynamicElementEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EReference getDynamicElement_Attributes() {
-		return (EReference)dynamicElementEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EAttribute getDynamicElement_TextContent() {
-		return (EAttribute)dynamicElementEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EClass getELResolverType() {
-		return elResolverTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EAttribute getELResolverType_TextContent() {
-		return (EAttribute)elResolverTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EAttribute getELResolverType_Id() {
-		return (EAttribute)elResolverTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getExceptionHandlerFactoryType() {
-		return exceptionHandlerFactoryTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getExceptionHandlerFactoryType_TextContent() {
-		return (EAttribute)exceptionHandlerFactoryTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getExceptionHandlerFactoryType_Id() {
-		return (EAttribute)exceptionHandlerFactoryTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EAttribute getDynamicElement_Name() {
-		return (EAttribute)dynamicElementEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getFacesConfigType() {
-		return facesConfigTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFacesConfigType_Application() {
-		return (EReference)facesConfigTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFacesConfigType_Ordering() {
-		return (EReference)facesConfigTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFacesConfigType_AbsoluteOrdering() {
-		return (EReference)facesConfigTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFacesConfigType_Factory() {
-		return (EReference)facesConfigTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFacesConfigType_Component() {
-		return (EReference)facesConfigTypeEClass.getEStructuralFeatures().get(4);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFacesConfigType_Converter() {
-		return (EReference)facesConfigTypeEClass.getEStructuralFeatures().get(5);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFacesConfigType_ManagedBean() {
-		return (EReference)facesConfigTypeEClass.getEStructuralFeatures().get(6);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFacesConfigType_Name() {
-		return (EReference)facesConfigTypeEClass.getEStructuralFeatures().get(7);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFacesConfigType_NavigationRule() {
-		return (EReference)facesConfigTypeEClass.getEStructuralFeatures().get(8);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFacesConfigType_ReferencedBean() {
-		return (EReference)facesConfigTypeEClass.getEStructuralFeatures().get(9);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFacesConfigType_RenderKit() {
-		return (EReference)facesConfigTypeEClass.getEStructuralFeatures().get(10);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFacesConfigType_Lifecycle() {
-		return (EReference)facesConfigTypeEClass.getEStructuralFeatures().get(11);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFacesConfigType_Validator() {
-		return (EReference)facesConfigTypeEClass.getEStructuralFeatures().get(12);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFacesConfigType_Behavior() {
-		return (EReference)facesConfigTypeEClass.getEStructuralFeatures().get(13);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EReference getFacesConfigType_FacesConfigExtension() {
-		return (EReference)facesConfigTypeEClass.getEStructuralFeatures().get(14);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFacesConfigType_Xmlns() {
-		return (EAttribute)facesConfigTypeEClass.getEStructuralFeatures().get(15);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFacesConfigType_Id() {
-		return (EAttribute)facesConfigTypeEClass.getEStructuralFeatures().get(16);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFacesConfigType_MetadataComplete() {
-		return (EAttribute)facesConfigTypeEClass.getEStructuralFeatures().get(17);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getFacesContextFactoryType() {
-		return facesContextFactoryTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFacesContextFactoryType_TextContent() {
-		return (EAttribute)facesContextFactoryTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFacesContextFactoryType_Id() {
-		return (EAttribute)facesContextFactoryTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getFacetExtensionType() {
-		return facetExtensionTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getFacetNameType() {
-		return facetNameTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFacetNameType_TextContent() {
-		return (EAttribute)facetNameTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFacetNameType_Id() {
-		return (EAttribute)facetNameTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getFacetType() {
-		return facetTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFacetType_Description() {
-		return (EReference)facetTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFacetType_DisplayName() {
-		return (EReference)facetTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFacetType_Icon() {
-		return (EReference)facetTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFacetType_FacetName() {
-		return (EReference)facetTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFacetType_FacetExtension() {
-		return (EReference)facetTypeEClass.getEStructuralFeatures().get(4);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFacetType_Id() {
-		return (EAttribute)facetTypeEClass.getEStructuralFeatures().get(5);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getFactoryType() {
-		return factoryTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFactoryType_ApplicationFactory() {
-		return (EReference)factoryTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFactoryType_ExceptionHandlerFactory() {
-		return (EReference)factoryTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFactoryType_ExternalContextFactory() {
-		return (EReference)factoryTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFactoryType_FacesContextFactory() {
-		return (EReference)factoryTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFactoryType_PartialViewContextFactory() {
-		return (EReference)factoryTypeEClass.getEStructuralFeatures().get(4);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFactoryType_LifecycleFactory() {
-		return (EReference)factoryTypeEClass.getEStructuralFeatures().get(5);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFactoryType_ViewDeclarationLanguageFactory() {
-		return (EReference)factoryTypeEClass.getEStructuralFeatures().get(6);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFactoryType_TagHandlerDelegateFactory() {
-		return (EReference)factoryTypeEClass.getEStructuralFeatures().get(7);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFactoryType_RenderKitFactory() {
-		return (EReference)factoryTypeEClass.getEStructuralFeatures().get(8);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getFactoryType_VisitContextFactory() {
-		return (EReference)factoryTypeEClass.getEStructuralFeatures().get(9);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EReference getFactoryType_FactoryExtension() {
-		return (EReference)factoryTypeEClass.getEStructuralFeatures().get(10);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFactoryType_Id() {
-		return (EAttribute)factoryTypeEClass.getEStructuralFeatures().get(11);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getFromActionType() {
-		return fromActionTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFromActionType_TextContent() {
-		return (EAttribute)fromActionTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFromActionType_Id() {
-		return (EAttribute)fromActionTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getFromOutcomeType() {
-		return fromOutcomeTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFromOutcomeType_TextContent() {
-		return (EAttribute)fromOutcomeTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFromOutcomeType_Id() {
-		return (EAttribute)fromOutcomeTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getFromViewIdType() {
-		return fromViewIdTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFromViewIdType_TextContent() {
-		return (EAttribute)fromViewIdTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getFromViewIdType_Id() {
-		return (EAttribute)fromViewIdTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getIconType() {
-		return iconTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getIconType_SmallIcon() {
-		return (EReference)iconTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getIconType_LargeIcon() {
-		return (EReference)iconTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getIconType_Lang() {
-		return (EAttribute)iconTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getIconType_Id() {
-		return (EAttribute)iconTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getIfType() {
-		return ifTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getIfType_TextContent() {
-		return (EAttribute)ifTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getIfType_Id() {
-		return (EAttribute)ifTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getKeyClassType() {
-		return keyClassTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getKeyClassType_TextContent() {
-		return (EAttribute)keyClassTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getKeyClassType_Id() {
-		return (EAttribute)keyClassTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getKeyType() {
-		return keyTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getKeyType_TextContent() {
-		return (EAttribute)keyTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getKeyType_Id() {
-		return (EAttribute)keyTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getLargeIconType() {
-		return largeIconTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getLargeIconType_TextContent() {
-		return (EAttribute)largeIconTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getLargeIconType_Id() {
-		return (EAttribute)largeIconTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getLifecycleFactoryType() {
-		return lifecycleFactoryTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getLifecycleFactoryType_TextContent() {
-		return (EAttribute)lifecycleFactoryTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getLifecycleFactoryType_Id() {
-		return (EAttribute)lifecycleFactoryTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getLifecycleType() {
-		return lifecycleTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getLifecycleType_PhaseListener() {
-		return (EReference)lifecycleTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EReference getLifecycleType_LifecycleExtension() {
-		return (EReference)lifecycleTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getLifecycleType_Id() {
-		return (EAttribute)lifecycleTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getListEntriesType() {
-		return listEntriesTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getListEntriesType_ValueClass() {
-		return (EReference)listEntriesTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getListEntriesType_NullValue() {
-		return (EReference)listEntriesTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getListEntriesType_Value() {
-		return (EReference)listEntriesTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getListEntriesType_Id() {
-		return (EAttribute)listEntriesTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getLocaleConfigType() {
-		return localeConfigTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getLocaleConfigType_DefaultLocale() {
-		return (EReference)localeConfigTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getLocaleConfigType_SupportedLocale() {
-		return (EReference)localeConfigTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getLocaleConfigType_Id() {
-		return (EAttribute)localeConfigTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getManagedBeanClassType() {
-		return managedBeanClassTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getManagedBeanClassType_TextContent() {
-		return (EAttribute)managedBeanClassTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getManagedBeanClassType_Id() {
-		return (EAttribute)managedBeanClassTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getManagedBeanNameType() {
-		return managedBeanNameTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getManagedBeanNameType_TextContent() {
-		return (EAttribute)managedBeanNameTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getManagedBeanNameType_Id() {
-		return (EAttribute)managedBeanNameTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getManagedBeanScopeType() {
-		return managedBeanScopeTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getManagedBeanScopeType_TextContent() {
-		return (EAttribute)managedBeanScopeTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getManagedBeanScopeType_Id() {
-		return (EAttribute)managedBeanScopeTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getManagedBeanType() {
-		return managedBeanTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getManagedBeanType_Description() {
-		return (EReference)managedBeanTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getManagedBeanType_DisplayName() {
-		return (EReference)managedBeanTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getManagedBeanType_Icon() {
-		return (EReference)managedBeanTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getManagedBeanType_ManagedBeanName() {
-		return (EReference)managedBeanTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getManagedBeanType_ManagedBeanClass() {
-		return (EReference)managedBeanTypeEClass.getEStructuralFeatures().get(4);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getManagedBeanType_ManagedBeanScope() {
-		return (EReference)managedBeanTypeEClass.getEStructuralFeatures().get(5);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getManagedBeanType_ManagedProperty() {
-		return (EReference)managedBeanTypeEClass.getEStructuralFeatures().get(6);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getManagedBeanType_MapEntries() {
-		return (EReference)managedBeanTypeEClass.getEStructuralFeatures().get(7);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getManagedBeanType_ListEntries() {
-		return (EReference)managedBeanTypeEClass.getEStructuralFeatures().get(8);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EReference getManagedBeanType_ManagedBeanExtension() {
-		return (EReference)managedBeanTypeEClass.getEStructuralFeatures().get(9);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getManagedBeanType_Id() {
-		return (EAttribute)managedBeanTypeEClass.getEStructuralFeatures().get(10);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getManagedBeanType_Eager() {
-		return (EAttribute)managedBeanTypeEClass.getEStructuralFeatures().get(11);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getManagedPropertyType() {
-		return managedPropertyTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getManagedPropertyType_Description() {
-		return (EReference)managedPropertyTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getManagedPropertyType_DisplayName() {
-		return (EReference)managedPropertyTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getManagedPropertyType_Icon() {
-		return (EReference)managedPropertyTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getManagedPropertyType_PropertyName() {
-		return (EReference)managedPropertyTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getManagedPropertyType_PropertyClass() {
-		return (EReference)managedPropertyTypeEClass.getEStructuralFeatures().get(4);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getManagedPropertyType_MapEntries() {
-		return (EReference)managedPropertyTypeEClass.getEStructuralFeatures().get(5);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getManagedPropertyType_NullValue() {
-		return (EReference)managedPropertyTypeEClass.getEStructuralFeatures().get(6);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getManagedPropertyType_Value() {
-		return (EReference)managedPropertyTypeEClass.getEStructuralFeatures().get(7);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getManagedPropertyType_ListEntries() {
-		return (EReference)managedPropertyTypeEClass.getEStructuralFeatures().get(8);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getManagedPropertyType_Id() {
-		return (EAttribute)managedPropertyTypeEClass.getEStructuralFeatures().get(9);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getMapEntriesType() {
-		return mapEntriesTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getMapEntriesType_KeyClass() {
-		return (EReference)mapEntriesTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getMapEntriesType_ValueClass() {
-		return (EReference)mapEntriesTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getMapEntriesType_MapEntry() {
-		return (EReference)mapEntriesTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getMapEntriesType_Id() {
-		return (EAttribute)mapEntriesTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getMapEntryType() {
-		return mapEntryTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getMapEntryType_Key() {
-		return (EReference)mapEntryTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getMapEntryType_NullValue() {
-		return (EReference)mapEntryTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getMapEntryType_Value() {
-		return (EReference)mapEntryTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getMapEntryType_Id() {
-		return (EAttribute)mapEntryTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getMessageBundleType() {
-		return messageBundleTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getMessageBundleType_TextContent() {
-		return (EAttribute)messageBundleTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getMessageBundleType_Id() {
-		return (EAttribute)messageBundleTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getNameType() {
-		return nameTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getNameType_TextContent() {
-		return (EAttribute)nameTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getNameType_Id() {
-		return (EAttribute)nameTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getNavigationCaseType() {
-		return navigationCaseTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getNavigationCaseType_Description() {
-		return (EReference)navigationCaseTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getNavigationCaseType_DisplayName() {
-		return (EReference)navigationCaseTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getNavigationCaseType_Icon() {
-		return (EReference)navigationCaseTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getNavigationCaseType_FromAction() {
-		return (EReference)navigationCaseTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getNavigationCaseType_FromOutcome() {
-		return (EReference)navigationCaseTypeEClass.getEStructuralFeatures().get(4);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getNavigationCaseType_If() {
-		return (EReference)navigationCaseTypeEClass.getEStructuralFeatures().get(5);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getNavigationCaseType_ToViewId() {
-		return (EReference)navigationCaseTypeEClass.getEStructuralFeatures().get(6);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getNavigationCaseType_Redirect() {
-		return (EReference)navigationCaseTypeEClass.getEStructuralFeatures().get(7);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getNavigationCaseType_Id() {
-		return (EAttribute)navigationCaseTypeEClass.getEStructuralFeatures().get(8);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getNavigationHandlerType() {
-		return navigationHandlerTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getNavigationHandlerType_TextContent() {
-		return (EAttribute)navigationHandlerTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getNavigationHandlerType_Id() {
-		return (EAttribute)navigationHandlerTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getNavigationRuleType() {
-		return navigationRuleTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getNavigationRuleType_Description() {
-		return (EReference)navigationRuleTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getNavigationRuleType_DisplayName() {
-		return (EReference)navigationRuleTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getNavigationRuleType_Icon() {
-		return (EReference)navigationRuleTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getNavigationRuleType_FromViewId() {
-		return (EReference)navigationRuleTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getNavigationRuleType_NavigationCase() {
-		return (EReference)navigationRuleTypeEClass.getEStructuralFeatures().get(4);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EReference getNavigationRuleType_NavigationRuleExtension() {
-		return (EReference)navigationRuleTypeEClass.getEStructuralFeatures().get(5);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getNavigationRuleType_Id() {
-		return (EAttribute)navigationRuleTypeEClass.getEStructuralFeatures().get(6);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getNullValueType() {
-		return nullValueTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getNullValueType_Id() {
-		return (EAttribute)nullValueTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getOrderingType() {
-		return orderingTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getOrderingType_Before() {
-		return (EReference)orderingTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getOrderingType_After() {
-		return (EReference)orderingTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getOrderingOrderingType() {
-		return orderingOrderingTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getOrderingOrderingType_Name() {
-		return (EReference)orderingOrderingTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getOrderingOrderingType_Others() {
-		return (EReference)orderingOrderingTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getOrderingOthersType() {
-		return orderingOthersTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getOrderingOthersType_Id() {
-		return (EAttribute)orderingOthersTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPartialViewContextFactoryType() {
-		return partialViewContextFactoryTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPartialViewContextFactoryType_TextContent() {
-		return (EAttribute)partialViewContextFactoryTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPartialViewContextFactoryType_Id() {
-		return (EAttribute)partialViewContextFactoryTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPhaseListenerType() {
-		return phaseListenerTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPhaseListenerType_TextContent() {
-		return (EAttribute)phaseListenerTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPhaseListenerType_Id() {
-		return (EAttribute)phaseListenerTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPropertyClassType() {
-		return propertyClassTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPropertyClassType_TextContent() {
-		return (EAttribute)propertyClassTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPropertyClassType_Id() {
-		return (EAttribute)propertyClassTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPropertyExtensionType() {
-		return propertyExtensionTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPropertyNameType() {
-		return propertyNameTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPropertyNameType_TextContent() {
-		return (EAttribute)propertyNameTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPropertyNameType_Id() {
-		return (EAttribute)propertyNameTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPropertyResolverType() {
-		return propertyResolverTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPropertyResolverType_TextContent() {
-		return (EAttribute)propertyResolverTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPropertyResolverType_Id() {
-		return (EAttribute)propertyResolverTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getPropertyType() {
-		return propertyTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPropertyType_Description() {
-		return (EReference)propertyTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPropertyType_DisplayName() {
-		return (EReference)propertyTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPropertyType_Icon() {
-		return (EReference)propertyTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPropertyType_PropertyName() {
-		return (EReference)propertyTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPropertyType_PropertyClass() {
-		return (EReference)propertyTypeEClass.getEStructuralFeatures().get(4);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPropertyType_DefaultValue() {
-		return (EReference)propertyTypeEClass.getEStructuralFeatures().get(5);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPropertyType_SuggestedValue() {
-		return (EReference)propertyTypeEClass.getEStructuralFeatures().get(6);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getPropertyType_PropertyExtension() {
-		return (EReference)propertyTypeEClass.getEStructuralFeatures().get(7);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getPropertyType_Id() {
-		return (EAttribute)propertyTypeEClass.getEStructuralFeatures().get(8);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getRedirectType() {
-		return redirectTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getRedirectType_ViewParam() {
-		return (EReference)redirectTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getRedirectType_Id() {
-		return (EAttribute)redirectTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getRedirectType_IncludeViewParams() {
-		return (EAttribute)redirectTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getRedirectViewParamType() {
-		return redirectViewParamTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getRedirectViewParamType_Name() {
-		return (EReference)redirectViewParamTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getRedirectViewParamType_Value() {
-		return (EReference)redirectViewParamTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getRedirectViewParamType_Id() {
-		return (EAttribute)redirectViewParamTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getReferencedBeanClassType() {
-		return referencedBeanClassTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getReferencedBeanClassType_TextContent() {
-		return (EAttribute)referencedBeanClassTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getReferencedBeanClassType_Id() {
-		return (EAttribute)referencedBeanClassTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getReferencedBeanNameType() {
-		return referencedBeanNameTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getReferencedBeanNameType_TextContent() {
-		return (EAttribute)referencedBeanNameTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getReferencedBeanNameType_Id() {
-		return (EAttribute)referencedBeanNameTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getReferencedBeanType() {
-		return referencedBeanTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getReferencedBeanType_Description() {
-		return (EReference)referencedBeanTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getReferencedBeanType_DisplayName() {
-		return (EReference)referencedBeanTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getReferencedBeanType_Icon() {
-		return (EReference)referencedBeanTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getReferencedBeanType_ReferencedBeanName() {
-		return (EReference)referencedBeanTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getReferencedBeanType_ReferencedBeanClass() {
-		return (EReference)referencedBeanTypeEClass.getEStructuralFeatures().get(4);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getReferencedBeanType_Id() {
-		return (EAttribute)referencedBeanTypeEClass.getEStructuralFeatures().get(5);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getRendererClassType() {
-		return rendererClassTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getRendererClassType_TextContent() {
-		return (EAttribute)rendererClassTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getRendererClassType_Id() {
-		return (EAttribute)rendererClassTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getRendererExtensionType() {
-		return rendererExtensionTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getRendererType() {
-		return rendererTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getRendererType_Description() {
-		return (EReference)rendererTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getRendererType_DisplayName() {
-		return (EReference)rendererTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getRendererType_Icon() {
-		return (EReference)rendererTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getRendererType_ComponentFamily() {
-		return (EReference)rendererTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getRendererType_RendererType() {
-		return (EReference)rendererTypeEClass.getEStructuralFeatures().get(4);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getRendererType_RendererClass() {
-		return (EReference)rendererTypeEClass.getEStructuralFeatures().get(5);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getRendererType_Facet() {
-		return (EReference)rendererTypeEClass.getEStructuralFeatures().get(6);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getRendererType_Attribute() {
-		return (EReference)rendererTypeEClass.getEStructuralFeatures().get(7);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getRendererType_RendererExtension() {
-		return (EReference)rendererTypeEClass.getEStructuralFeatures().get(8);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getRendererType_Id() {
-		return (EAttribute)rendererTypeEClass.getEStructuralFeatures().get(9);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getRendererTypeType() {
-		return rendererTypeTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getRendererTypeType_TextContent() {
-		return (EAttribute)rendererTypeTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getRendererTypeType_Id() {
-		return (EAttribute)rendererTypeTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getRenderKitClassType() {
-		return renderKitClassTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getRenderKitClassType_TextContent() {
-		return (EAttribute)renderKitClassTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getRenderKitClassType_Id() {
-		return (EAttribute)renderKitClassTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getRenderKitFactoryType() {
-		return renderKitFactoryTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getRenderKitFactoryType_TextContent() {
-		return (EAttribute)renderKitFactoryTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getRenderKitFactoryType_Id() {
-		return (EAttribute)renderKitFactoryTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getRenderKitIdType() {
-		return renderKitIdTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getRenderKitIdType_TextContent() {
-		return (EAttribute)renderKitIdTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getRenderKitIdType_Id() {
-		return (EAttribute)renderKitIdTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getRenderKitType() {
-		return renderKitTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getRenderKitType_Description() {
-		return (EReference)renderKitTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getRenderKitType_DisplayName() {
-		return (EReference)renderKitTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getRenderKitType_Icon() {
-		return (EReference)renderKitTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getRenderKitType_RenderKitId() {
-		return (EReference)renderKitTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getRenderKitType_RenderKitClass() {
-		return (EReference)renderKitTypeEClass.getEStructuralFeatures().get(4);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getRenderKitType_Renderer() {
-		return (EReference)renderKitTypeEClass.getEStructuralFeatures().get(5);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getRenderKitType_ClientBehaviorRenderer() {
-		return (EReference)renderKitTypeEClass.getEStructuralFeatures().get(6);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EReference getRenderKitType_RenderKitExtension() {
-		return (EReference)renderKitTypeEClass.getEStructuralFeatures().get(7);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getRenderKitType_Id() {
-		return (EAttribute)renderKitTypeEClass.getEStructuralFeatures().get(8);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getSmallIconType() {
-		return smallIconTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getSmallIconType_TextContent() {
-		return (EAttribute)smallIconTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getSmallIconType_Id() {
-		return (EAttribute)smallIconTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getSourceClassType() {
-		return sourceClassTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getSourceClassType_TextContent() {
-		return (EAttribute)sourceClassTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getSourceClassType_Id() {
-		return (EAttribute)sourceClassTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getStateManagerType() {
-		return stateManagerTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getStateManagerType_TextContent() {
-		return (EAttribute)stateManagerTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getStateManagerType_Id() {
-		return (EAttribute)stateManagerTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getSuggestedValueType() {
-		return suggestedValueTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getSuggestedValueType_TextContent() {
-		return (EAttribute)suggestedValueTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getSuggestedValueType_Id() {
-		return (EAttribute)suggestedValueTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getSupportedLocaleType() {
-		return supportedLocaleTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getSupportedLocaleType_TextContent() {
-		return (EAttribute)supportedLocaleTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getSupportedLocaleType_Id() {
-		return (EAttribute)supportedLocaleTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getSystemEventClassType() {
-		return systemEventClassTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getSystemEventClassType_TextContent() {
-		return (EAttribute)systemEventClassTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getSystemEventClassType_Id() {
-		return (EAttribute)systemEventClassTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getSystemEventListenerClassType() {
-		return systemEventListenerClassTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getSystemEventListenerClassType_TextContent() {
-		return (EAttribute)systemEventListenerClassTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getSystemEventListenerClassType_Id() {
-		return (EAttribute)systemEventListenerClassTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getSystemEventListenerType() {
-		return systemEventListenerTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getSystemEventListenerType_SystemEventListenerClass() {
-		return (EReference)systemEventListenerTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getSystemEventListenerType_SystemEventClass() {
-		return (EReference)systemEventListenerTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getSystemEventListenerType_SourceClass() {
-		return (EReference)systemEventListenerTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getSystemEventListenerType_Id() {
-		return (EAttribute)systemEventListenerTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getTagHandlerDelegateFactoryType() {
-		return tagHandlerDelegateFactoryTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getTagHandlerDelegateFactoryType_TextContent() {
-		return (EAttribute)tagHandlerDelegateFactoryTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getTagHandlerDelegateFactoryType_Id() {
-		return (EAttribute)tagHandlerDelegateFactoryTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getToViewIdType() {
-		return toViewIdTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getToViewIdType_TextContent() {
-		return (EAttribute)toViewIdTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getToViewIdType_Id() {
-		return (EAttribute)toViewIdTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getValidatorClassType() {
-		return validatorClassTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getValidatorClassType_TextContent() {
-		return (EAttribute)validatorClassTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getValidatorClassType_Id() {
-		return (EAttribute)validatorClassTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getValidatorIdType() {
-		return validatorIdTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getValidatorIdType_TextContent() {
-		return (EAttribute)validatorIdTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getValidatorIdType_Id() {
-		return (EAttribute)validatorIdTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getValidatorType() {
-		return validatorTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getValidatorType_Description() {
-		return (EReference)validatorTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getValidatorType_DisplayName() {
-		return (EReference)validatorTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getValidatorType_Icon() {
-		return (EReference)validatorTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getValidatorType_ValidatorId() {
-		return (EReference)validatorTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getValidatorType_ValidatorClass() {
-		return (EReference)validatorTypeEClass.getEStructuralFeatures().get(4);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getValidatorType_Attribute() {
-		return (EReference)validatorTypeEClass.getEStructuralFeatures().get(5);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getValidatorType_Property() {
-		return (EReference)validatorTypeEClass.getEStructuralFeatures().get(6);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EReference getValidatorType_ValidatorExtension() {
-		return (EReference)validatorTypeEClass.getEStructuralFeatures().get(7);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getValidatorType_Id() {
-		return (EAttribute)validatorTypeEClass.getEStructuralFeatures().get(8);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getValueClassType() {
-		return valueClassTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getValueClassType_TextContent() {
-		return (EAttribute)valueClassTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getValueClassType_Id() {
-		return (EAttribute)valueClassTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getValueType() {
-		return valueTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getValueType_TextContent() {
-		return (EAttribute)valueTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getValueType_Id() {
-		return (EAttribute)valueTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getVariableResolverType() {
-		return variableResolverTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getVariableResolverType_TextContent() {
-		return (EAttribute)variableResolverTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getVariableResolverType_Id() {
-		return (EAttribute)variableResolverTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getViewHandlerType() {
-		return viewHandlerTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getViewHandlerType_TextContent() {
-		return (EAttribute)viewHandlerTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getViewHandlerType_Id() {
-		return (EAttribute)viewHandlerTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EClass getResourceBundleType() {
-		return resourceBundleTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EReference getResourceBundleType_Description() {
-		return (EReference)resourceBundleTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EReference getResourceBundleType_DisplayName() {
-		return (EReference)resourceBundleTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EReference getResourceBundleType_Icon() {
-		return (EReference)resourceBundleTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EReference getResourceBundleType_BaseName() {
-		return (EReference)resourceBundleTypeEClass.getEStructuralFeatures().get(3);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EReference getResourceBundleType_Var() {
-		return (EReference)resourceBundleTypeEClass.getEStructuralFeatures().get(4);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EAttribute getResourceBundleType_Id() {
-		return (EAttribute)resourceBundleTypeEClass.getEStructuralFeatures().get(5);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EClass getBaseNameType() {
-		return baseNameTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EAttribute getBaseNameType_TextContent() {
-		return (EAttribute)baseNameTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EAttribute getBaseNameType_Id() {
-		return (EAttribute)baseNameTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EClass getVarType() {
-		return varTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EAttribute getVarType_TextContent() {
-		return (EAttribute)varTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EAttribute getVarType_Id() {
-		return (EAttribute)varTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getViewDeclarationLanguageFactoryType() {
-		return viewDeclarationLanguageFactoryTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getViewDeclarationLanguageFactoryType_TextContent() {
-		return (EAttribute)viewDeclarationLanguageFactoryTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getViewDeclarationLanguageFactoryType_Id() {
-		return (EAttribute)viewDeclarationLanguageFactoryTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getVisitContextFactoryType() {
-		return visitContextFactoryTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getVisitContextFactoryType_TextContent() {
-		return (EAttribute)visitContextFactoryTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getVisitContextFactoryType_Id() {
-		return (EAttribute)visitContextFactoryTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EClass getRenderKitExtensionType() {
-		return renderKitExtensionTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getResourceHandlerType() {
-		return resourceHandlerTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getResourceHandlerType_TextContent() {
-		return (EAttribute)resourceHandlerTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getResourceHandlerType_Id() {
-		return (EAttribute)resourceHandlerTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EClass getNavigationRuleExtensionType() {
-		return navigationRuleExtensionTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EClass getValidatorExtensionType() {
-		return validatorExtensionTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EClass getFacesConfigExtensionType() {
-		return facesConfigExtensionTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EClass getFactoryExtensionType() {
-		return factoryExtensionTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EClass getLifecycleExtensionType() {
-		return lifecycleExtensionTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EClass getManagedBeanExtensionType() {
-		return managedBeanExtensionTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EClass getConverterExtensionType() {
-		return converterExtensionTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EClass getExtensionType() {
-		return extensionTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EReference getExtensionType_ChildNodes() {
-		return (EReference)extensionTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EAttribute getExtensionType_TextContent() {
-		return (EAttribute)extensionTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EAttribute getExtensionType_Id() {
-		return (EAttribute)extensionTypeEClass.getEStructuralFeatures().get(2);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getExternalContextFactoryType() {
-		return externalContextFactoryTypeEClass;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getExternalContextFactoryType_TextContent() {
-		return (EAttribute)externalContextFactoryTypeEClass.getEStructuralFeatures().get(0);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getExternalContextFactoryType_Id() {
-		return (EAttribute)externalContextFactoryTypeEClass.getEStructuralFeatures().get(1);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EClass getApplicationExtensionType() {
-		return applicationExtensionTypeEClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FacesConfigFactory getFacesConfigFactory() {
-		return (FacesConfigFactory)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
-		absoluteOrderingTypeEClass = createEClass(ABSOLUTE_ORDERING_TYPE);
-		createEReference(absoluteOrderingTypeEClass, ABSOLUTE_ORDERING_TYPE__NAME);
-		createEReference(absoluteOrderingTypeEClass, ABSOLUTE_ORDERING_TYPE__OTHERS);
-
-		actionListenerTypeEClass = createEClass(ACTION_LISTENER_TYPE);
-		createEAttribute(actionListenerTypeEClass, ACTION_LISTENER_TYPE__TEXT_CONTENT);
-		createEAttribute(actionListenerTypeEClass, ACTION_LISTENER_TYPE__ID);
-
-		applicationFactoryTypeEClass = createEClass(APPLICATION_FACTORY_TYPE);
-		createEAttribute(applicationFactoryTypeEClass, APPLICATION_FACTORY_TYPE__TEXT_CONTENT);
-		createEAttribute(applicationFactoryTypeEClass, APPLICATION_FACTORY_TYPE__ID);
-
-		applicationTypeEClass = createEClass(APPLICATION_TYPE);
-		createEReference(applicationTypeEClass, APPLICATION_TYPE__ACTION_LISTENER);
-		createEReference(applicationTypeEClass, APPLICATION_TYPE__DEFAULT_RENDER_KIT_ID);
-		createEReference(applicationTypeEClass, APPLICATION_TYPE__MESSAGE_BUNDLE);
-		createEReference(applicationTypeEClass, APPLICATION_TYPE__NAVIGATION_HANDLER);
-		createEReference(applicationTypeEClass, APPLICATION_TYPE__VIEW_HANDLER);
-		createEReference(applicationTypeEClass, APPLICATION_TYPE__STATE_MANAGER);
-		createEReference(applicationTypeEClass, APPLICATION_TYPE__EL_RESOLVER);
-		createEReference(applicationTypeEClass, APPLICATION_TYPE__PROPERTY_RESOLVER);
-		createEReference(applicationTypeEClass, APPLICATION_TYPE__VARIABLE_RESOLVER);
-		createEReference(applicationTypeEClass, APPLICATION_TYPE__RESOURCE_HANDLER);
-		createEReference(applicationTypeEClass, APPLICATION_TYPE__SYSTEM_EVENT_LISTENER);
-		createEReference(applicationTypeEClass, APPLICATION_TYPE__LOCALE_CONFIG);
-		createEReference(applicationTypeEClass, APPLICATION_TYPE__RESOURCE_BUNDLE);
-		createEReference(applicationTypeEClass, APPLICATION_TYPE__APPLICATION_EXTENSION);
-		createEReference(applicationTypeEClass, APPLICATION_TYPE__DEFAULT_VALIDATORS);
-		createEAttribute(applicationTypeEClass, APPLICATION_TYPE__ID);
-
-		applicationExtensionTypeEClass = createEClass(APPLICATION_EXTENSION_TYPE);
-
-		attributeClassTypeEClass = createEClass(ATTRIBUTE_CLASS_TYPE);
-		createEAttribute(attributeClassTypeEClass, ATTRIBUTE_CLASS_TYPE__TEXT_CONTENT);
-		createEAttribute(attributeClassTypeEClass, ATTRIBUTE_CLASS_TYPE__ID);
-
-		attributeExtensionTypeEClass = createEClass(ATTRIBUTE_EXTENSION_TYPE);
-
-		attributeNameTypeEClass = createEClass(ATTRIBUTE_NAME_TYPE);
-		createEAttribute(attributeNameTypeEClass, ATTRIBUTE_NAME_TYPE__TEXT_CONTENT);
-		createEAttribute(attributeNameTypeEClass, ATTRIBUTE_NAME_TYPE__ID);
-
-		attributeTypeEClass = createEClass(ATTRIBUTE_TYPE);
-		createEReference(attributeTypeEClass, ATTRIBUTE_TYPE__DESCRIPTION);
-		createEReference(attributeTypeEClass, ATTRIBUTE_TYPE__DISPLAY_NAME);
-		createEReference(attributeTypeEClass, ATTRIBUTE_TYPE__ICON);
-		createEReference(attributeTypeEClass, ATTRIBUTE_TYPE__ATTRIBUTE_NAME);
-		createEReference(attributeTypeEClass, ATTRIBUTE_TYPE__ATTRIBUTE_CLASS);
-		createEReference(attributeTypeEClass, ATTRIBUTE_TYPE__DEFAULT_VALUE);
-		createEReference(attributeTypeEClass, ATTRIBUTE_TYPE__SUGGESTED_VALUE);
-		createEReference(attributeTypeEClass, ATTRIBUTE_TYPE__ATTRIBUTE_EXTENSION);
-		createEAttribute(attributeTypeEClass, ATTRIBUTE_TYPE__ID);
-
-		behaviorClassTypeEClass = createEClass(BEHAVIOR_CLASS_TYPE);
-		createEAttribute(behaviorClassTypeEClass, BEHAVIOR_CLASS_TYPE__TEXT_CONTENT);
-		createEAttribute(behaviorClassTypeEClass, BEHAVIOR_CLASS_TYPE__ID);
-
-		behaviorIdTypeEClass = createEClass(BEHAVIOR_ID_TYPE);
-		createEAttribute(behaviorIdTypeEClass, BEHAVIOR_ID_TYPE__TEXT_CONTENT);
-		createEAttribute(behaviorIdTypeEClass, BEHAVIOR_ID_TYPE__ID);
-
-		behaviorTypeEClass = createEClass(BEHAVIOR_TYPE);
-		createEReference(behaviorTypeEClass, BEHAVIOR_TYPE__DESCRIPTION);
-		createEReference(behaviorTypeEClass, BEHAVIOR_TYPE__DISPLAY_NAME);
-		createEReference(behaviorTypeEClass, BEHAVIOR_TYPE__ICON);
-		createEReference(behaviorTypeEClass, BEHAVIOR_TYPE__BEHAVIOR_ID);
-		createEReference(behaviorTypeEClass, BEHAVIOR_TYPE__BEHAVIOR_CLASS);
-		createEReference(behaviorTypeEClass, BEHAVIOR_TYPE__ATTRIBUTE);
-		createEReference(behaviorTypeEClass, BEHAVIOR_TYPE__PROPERTY);
-		createEReference(behaviorTypeEClass, BEHAVIOR_TYPE__BEHAVIOR_EXTENSION);
-
-		behaviorExtensionTypeEClass = createEClass(BEHAVIOR_EXTENSION_TYPE);
-
-		clientBehaviorRendererClassTypeEClass = createEClass(CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE);
-		createEAttribute(clientBehaviorRendererClassTypeEClass, CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE__TEXT_CONTENT);
-		createEAttribute(clientBehaviorRendererClassTypeEClass, CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE__ID);
-
-		clientBehaviorRendererTypeEClass = createEClass(CLIENT_BEHAVIOR_RENDERER_TYPE);
-		createEReference(clientBehaviorRendererTypeEClass, CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_TYPE);
-		createEReference(clientBehaviorRendererTypeEClass, CLIENT_BEHAVIOR_RENDERER_TYPE__CLIENT_BEHAVIOR_RENDERER_CLASS);
-
-		clientBehaviorRendererTypeTypeEClass = createEClass(CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE);
-		createEAttribute(clientBehaviorRendererTypeTypeEClass, CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE__TEXT_CONTENT);
-		createEAttribute(clientBehaviorRendererTypeTypeEClass, CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE__ID);
-
-		componentClassTypeEClass = createEClass(COMPONENT_CLASS_TYPE);
-		createEAttribute(componentClassTypeEClass, COMPONENT_CLASS_TYPE__TEXT_CONTENT);
-		createEAttribute(componentClassTypeEClass, COMPONENT_CLASS_TYPE__ID);
-
-		componentExtensionTypeEClass = createEClass(COMPONENT_EXTENSION_TYPE);
-
-		componentFamilyTypeEClass = createEClass(COMPONENT_FAMILY_TYPE);
-		createEAttribute(componentFamilyTypeEClass, COMPONENT_FAMILY_TYPE__TEXT_CONTENT);
-		createEAttribute(componentFamilyTypeEClass, COMPONENT_FAMILY_TYPE__ID);
-
-		componentTypeEClass = createEClass(COMPONENT_TYPE);
-		createEReference(componentTypeEClass, COMPONENT_TYPE__DESCRIPTION);
-		createEReference(componentTypeEClass, COMPONENT_TYPE__DISPLAY_NAME);
-		createEReference(componentTypeEClass, COMPONENT_TYPE__ICON);
-		createEReference(componentTypeEClass, COMPONENT_TYPE__COMPONENT_TYPE);
-		createEReference(componentTypeEClass, COMPONENT_TYPE__COMPONENT_CLASS);
-		createEReference(componentTypeEClass, COMPONENT_TYPE__FACET);
-		createEReference(componentTypeEClass, COMPONENT_TYPE__ATTRIBUTE);
-		createEReference(componentTypeEClass, COMPONENT_TYPE__PROPERTY);
-		createEReference(componentTypeEClass, COMPONENT_TYPE__COMPONENT_EXTENSION);
-		createEAttribute(componentTypeEClass, COMPONENT_TYPE__ID);
-
-		componentTypeTypeEClass = createEClass(COMPONENT_TYPE_TYPE);
-		createEAttribute(componentTypeTypeEClass, COMPONENT_TYPE_TYPE__TEXT_CONTENT);
-		createEAttribute(componentTypeTypeEClass, COMPONENT_TYPE_TYPE__ID);
-
-		converterClassTypeEClass = createEClass(CONVERTER_CLASS_TYPE);
-		createEAttribute(converterClassTypeEClass, CONVERTER_CLASS_TYPE__TEXT_CONTENT);
-		createEAttribute(converterClassTypeEClass, CONVERTER_CLASS_TYPE__ID);
-
-		converterForClassTypeEClass = createEClass(CONVERTER_FOR_CLASS_TYPE);
-		createEAttribute(converterForClassTypeEClass, CONVERTER_FOR_CLASS_TYPE__TEXT_CONTENT);
-		createEAttribute(converterForClassTypeEClass, CONVERTER_FOR_CLASS_TYPE__ID);
-
-		converterIdTypeEClass = createEClass(CONVERTER_ID_TYPE);
-		createEAttribute(converterIdTypeEClass, CONVERTER_ID_TYPE__TEXT_CONTENT);
-		createEAttribute(converterIdTypeEClass, CONVERTER_ID_TYPE__ID);
-
-		converterTypeEClass = createEClass(CONVERTER_TYPE);
-		createEReference(converterTypeEClass, CONVERTER_TYPE__DESCRIPTION);
-		createEReference(converterTypeEClass, CONVERTER_TYPE__DISPLAY_NAME);
-		createEReference(converterTypeEClass, CONVERTER_TYPE__ICON);
-		createEReference(converterTypeEClass, CONVERTER_TYPE__CONVERTER_ID);
-		createEReference(converterTypeEClass, CONVERTER_TYPE__CONVERTER_FOR_CLASS);
-		createEReference(converterTypeEClass, CONVERTER_TYPE__CONVERTER_CLASS);
-		createEReference(converterTypeEClass, CONVERTER_TYPE__ATTRIBUTE);
-		createEReference(converterTypeEClass, CONVERTER_TYPE__PROPERTY);
-		createEReference(converterTypeEClass, CONVERTER_TYPE__CONVERTER_EXTENSION);
-		createEAttribute(converterTypeEClass, CONVERTER_TYPE__ID);
-
-		converterExtensionTypeEClass = createEClass(CONVERTER_EXTENSION_TYPE);
-
-		defaultLocaleTypeEClass = createEClass(DEFAULT_LOCALE_TYPE);
-		createEAttribute(defaultLocaleTypeEClass, DEFAULT_LOCALE_TYPE__TEXT_CONTENT);
-		createEAttribute(defaultLocaleTypeEClass, DEFAULT_LOCALE_TYPE__ID);
-
-		defaultRenderKitIdTypeEClass = createEClass(DEFAULT_RENDER_KIT_ID_TYPE);
-		createEAttribute(defaultRenderKitIdTypeEClass, DEFAULT_RENDER_KIT_ID_TYPE__TEXT_CONTENT);
-		createEAttribute(defaultRenderKitIdTypeEClass, DEFAULT_RENDER_KIT_ID_TYPE__ID);
-
-		defaultValidatorsTypeEClass = createEClass(DEFAULT_VALIDATORS_TYPE);
-		createEReference(defaultValidatorsTypeEClass, DEFAULT_VALIDATORS_TYPE__VALIDATOR_ID);
-		createEAttribute(defaultValidatorsTypeEClass, DEFAULT_VALIDATORS_TYPE__ID);
-
-		defaultValueTypeEClass = createEClass(DEFAULT_VALUE_TYPE);
-		createEAttribute(defaultValueTypeEClass, DEFAULT_VALUE_TYPE__TEXT_CONTENT);
-		createEAttribute(defaultValueTypeEClass, DEFAULT_VALUE_TYPE__ID);
-
-		descriptionTypeEClass = createEClass(DESCRIPTION_TYPE);
-		createEAttribute(descriptionTypeEClass, DESCRIPTION_TYPE__TEXT_CONTENT);
-		createEAttribute(descriptionTypeEClass, DESCRIPTION_TYPE__LANG);
-		createEAttribute(descriptionTypeEClass, DESCRIPTION_TYPE__ID);
-
-		displayNameTypeEClass = createEClass(DISPLAY_NAME_TYPE);
-		createEAttribute(displayNameTypeEClass, DISPLAY_NAME_TYPE__TEXT_CONTENT);
-		createEAttribute(displayNameTypeEClass, DISPLAY_NAME_TYPE__LANG);
-		createEAttribute(displayNameTypeEClass, DISPLAY_NAME_TYPE__ID);
-
-		documentRootEClass = createEClass(DOCUMENT_ROOT);
-		createEAttribute(documentRootEClass, DOCUMENT_ROOT__MIXED);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__XMLNS_PREFIX_MAP);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__XSI_SCHEMA_LOCATION);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__ABSOLUTE_ORDERING);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__ACTION_LISTENER);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__APPLICATION);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__APPLICATION_FACTORY);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__ATTRIBUTE);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__ATTRIBUTE_CLASS);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__ATTRIBUTE_EXTENSION);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__ATTRIBUTE_NAME);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__BEHAVIOR);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__BEHAVIOR_CLASS);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__BEHAVIOR_ID);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__BEHAVIOR_EXTENSION);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__COMPONENT);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__COMPONENT_CLASS);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__COMPONENT_EXTENSION);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__COMPONENT_FAMILY);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__COMPONENT_TYPE);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__CONVERTER);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__CONVERTER_CLASS);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__CONVERTER_FOR_CLASS);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__CONVERTER_ID);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__DEFAULT_LOCALE);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__DEFAULT_RENDER_KIT_ID);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__DEFAULT_VALIDATORS);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__DEFAULT_VALUE);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__DESCRIPTION);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__DISPLAY_NAME);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__EXCEPTION_HANDLER_FACTORY);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__EXTERNAL_CONTEXT_FACTORY);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__FACES_CONFIG);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__FACES_CONTEXT_FACTORY);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__FACET);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__FACET_EXTENSION);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__FACET_NAME);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__FACTORY);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__FROM_ACTION);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__FROM_OUTCOME);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__FROM_VIEW_ID);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__ICON);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__IF);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__KEY);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__KEY_CLASS);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__LARGE_ICON);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__LIFECYCLE);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__LIFECYCLE_FACTORY);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__LIST_ENTRIES);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__LOCALE_CONFIG);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__MANAGED_BEAN);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__MANAGED_BEAN_CLASS);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__MANAGED_BEAN_NAME);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__MANAGED_BEAN_SCOPE);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__MANAGED_PROPERTY);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__MAP_ENTRIES);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__MAP_ENTRY);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__MESSAGE_BUNDLE);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__NAME);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__NAVIGATION_CASE);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__NAVIGATION_HANDLER);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__NAVIGATION_RULE);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__NULL_VALUE);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__ORDERING);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__ORDERING_ORDERING);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__OTHERS);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__PARTIAL_VIEW_CONTEXT_FACTORY);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__PHASE_LISTENER);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__PROPERTY);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__PROPERTY_CLASS);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__PROPERTY_EXTENSION);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__PROPERTY_NAME);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__PROPERTY_RESOLVER);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__REDIRECT);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__REDIRECT_VIEW_PARAM);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__REFERENCED_BEAN);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__REFERENCED_BEAN_CLASS);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__REFERENCED_BEAN_NAME);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__RENDERER);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__RENDERER_CLASS);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__RENDERER_EXTENSION);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__RENDERER_TYPE);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__RENDER_KIT);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__RENDER_KIT_CLASS);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__RENDER_KIT_FACTORY);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__RENDER_KIT_ID);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__RESOURCE_HANDLER);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__SMALL_ICON);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__SOURCE_CLASS);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__STATE_MANAGER);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__SUGGESTED_VALUE);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__SUPPORTED_LOCALE);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__SYSTEM_EVENT_CLASS);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__SYSTEM_EVENT_LISTENER_CLASS);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__TAG_HANDLER_DELEGATE_FACTORY);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__TO_VIEW_ID);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__VALIDATOR);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__VALIDATOR_CLASS);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__VALIDATOR_ID);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__VALUE);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__VALUE_CLASS);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__VARIABLE_RESOLVER);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__VIEW_DECLARATION_LANGUAGE_FACTORY);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__VIEW_HANDLER);
-		createEReference(documentRootEClass, DOCUMENT_ROOT__VISIT_CONTEXT_FACTORY);
-
-		dynamicAttributeEClass = createEClass(DYNAMIC_ATTRIBUTE);
-		createEAttribute(dynamicAttributeEClass, DYNAMIC_ATTRIBUTE__NAME);
-		createEAttribute(dynamicAttributeEClass, DYNAMIC_ATTRIBUTE__VALUE);
-
-		dynamicElementEClass = createEClass(DYNAMIC_ELEMENT);
-		createEReference(dynamicElementEClass, DYNAMIC_ELEMENT__CHILD_NODES);
-		createEAttribute(dynamicElementEClass, DYNAMIC_ELEMENT__NAME);
-		createEReference(dynamicElementEClass, DYNAMIC_ELEMENT__ATTRIBUTES);
-		createEAttribute(dynamicElementEClass, DYNAMIC_ELEMENT__TEXT_CONTENT);
-
-		elResolverTypeEClass = createEClass(EL_RESOLVER_TYPE);
-		createEAttribute(elResolverTypeEClass, EL_RESOLVER_TYPE__TEXT_CONTENT);
-		createEAttribute(elResolverTypeEClass, EL_RESOLVER_TYPE__ID);
-
-		exceptionHandlerFactoryTypeEClass = createEClass(EXCEPTION_HANDLER_FACTORY_TYPE);
-		createEAttribute(exceptionHandlerFactoryTypeEClass, EXCEPTION_HANDLER_FACTORY_TYPE__TEXT_CONTENT);
-		createEAttribute(exceptionHandlerFactoryTypeEClass, EXCEPTION_HANDLER_FACTORY_TYPE__ID);
-
-		extensionTypeEClass = createEClass(EXTENSION_TYPE);
-		createEReference(extensionTypeEClass, EXTENSION_TYPE__CHILD_NODES);
-		createEAttribute(extensionTypeEClass, EXTENSION_TYPE__TEXT_CONTENT);
-		createEAttribute(extensionTypeEClass, EXTENSION_TYPE__ID);
-
-		externalContextFactoryTypeEClass = createEClass(EXTERNAL_CONTEXT_FACTORY_TYPE);
-		createEAttribute(externalContextFactoryTypeEClass, EXTERNAL_CONTEXT_FACTORY_TYPE__TEXT_CONTENT);
-		createEAttribute(externalContextFactoryTypeEClass, EXTERNAL_CONTEXT_FACTORY_TYPE__ID);
-
-		facesConfigTypeEClass = createEClass(FACES_CONFIG_TYPE);
-		createEReference(facesConfigTypeEClass, FACES_CONFIG_TYPE__APPLICATION);
-		createEReference(facesConfigTypeEClass, FACES_CONFIG_TYPE__ORDERING);
-		createEReference(facesConfigTypeEClass, FACES_CONFIG_TYPE__ABSOLUTE_ORDERING);
-		createEReference(facesConfigTypeEClass, FACES_CONFIG_TYPE__FACTORY);
-		createEReference(facesConfigTypeEClass, FACES_CONFIG_TYPE__COMPONENT);
-		createEReference(facesConfigTypeEClass, FACES_CONFIG_TYPE__CONVERTER);
-		createEReference(facesConfigTypeEClass, FACES_CONFIG_TYPE__MANAGED_BEAN);
-		createEReference(facesConfigTypeEClass, FACES_CONFIG_TYPE__NAME);
-		createEReference(facesConfigTypeEClass, FACES_CONFIG_TYPE__NAVIGATION_RULE);
-		createEReference(facesConfigTypeEClass, FACES_CONFIG_TYPE__REFERENCED_BEAN);
-		createEReference(facesConfigTypeEClass, FACES_CONFIG_TYPE__RENDER_KIT);
-		createEReference(facesConfigTypeEClass, FACES_CONFIG_TYPE__LIFECYCLE);
-		createEReference(facesConfigTypeEClass, FACES_CONFIG_TYPE__VALIDATOR);
-		createEReference(facesConfigTypeEClass, FACES_CONFIG_TYPE__BEHAVIOR);
-		createEReference(facesConfigTypeEClass, FACES_CONFIG_TYPE__FACES_CONFIG_EXTENSION);
-		createEAttribute(facesConfigTypeEClass, FACES_CONFIG_TYPE__XMLNS);
-		createEAttribute(facesConfigTypeEClass, FACES_CONFIG_TYPE__ID);
-		createEAttribute(facesConfigTypeEClass, FACES_CONFIG_TYPE__METADATA_COMPLETE);
-
-		facesConfigExtensionTypeEClass = createEClass(FACES_CONFIG_EXTENSION_TYPE);
-
-		facesContextFactoryTypeEClass = createEClass(FACES_CONTEXT_FACTORY_TYPE);
-		createEAttribute(facesContextFactoryTypeEClass, FACES_CONTEXT_FACTORY_TYPE__TEXT_CONTENT);
-		createEAttribute(facesContextFactoryTypeEClass, FACES_CONTEXT_FACTORY_TYPE__ID);
-
-		facetExtensionTypeEClass = createEClass(FACET_EXTENSION_TYPE);
-
-		facetNameTypeEClass = createEClass(FACET_NAME_TYPE);
-		createEAttribute(facetNameTypeEClass, FACET_NAME_TYPE__TEXT_CONTENT);
-		createEAttribute(facetNameTypeEClass, FACET_NAME_TYPE__ID);
-
-		facetTypeEClass = createEClass(FACET_TYPE);
-		createEReference(facetTypeEClass, FACET_TYPE__DESCRIPTION);
-		createEReference(facetTypeEClass, FACET_TYPE__DISPLAY_NAME);
-		createEReference(facetTypeEClass, FACET_TYPE__ICON);
-		createEReference(facetTypeEClass, FACET_TYPE__FACET_NAME);
-		createEReference(facetTypeEClass, FACET_TYPE__FACET_EXTENSION);
-		createEAttribute(facetTypeEClass, FACET_TYPE__ID);
-
-		factoryTypeEClass = createEClass(FACTORY_TYPE);
-		createEReference(factoryTypeEClass, FACTORY_TYPE__APPLICATION_FACTORY);
-		createEReference(factoryTypeEClass, FACTORY_TYPE__EXCEPTION_HANDLER_FACTORY);
-		createEReference(factoryTypeEClass, FACTORY_TYPE__EXTERNAL_CONTEXT_FACTORY);
-		createEReference(factoryTypeEClass, FACTORY_TYPE__FACES_CONTEXT_FACTORY);
-		createEReference(factoryTypeEClass, FACTORY_TYPE__PARTIAL_VIEW_CONTEXT_FACTORY);
-		createEReference(factoryTypeEClass, FACTORY_TYPE__LIFECYCLE_FACTORY);
-		createEReference(factoryTypeEClass, FACTORY_TYPE__VIEW_DECLARATION_LANGUAGE_FACTORY);
-		createEReference(factoryTypeEClass, FACTORY_TYPE__TAG_HANDLER_DELEGATE_FACTORY);
-		createEReference(factoryTypeEClass, FACTORY_TYPE__RENDER_KIT_FACTORY);
-		createEReference(factoryTypeEClass, FACTORY_TYPE__VISIT_CONTEXT_FACTORY);
-		createEReference(factoryTypeEClass, FACTORY_TYPE__FACTORY_EXTENSION);
-		createEAttribute(factoryTypeEClass, FACTORY_TYPE__ID);
-
-		factoryExtensionTypeEClass = createEClass(FACTORY_EXTENSION_TYPE);
-
-		fromActionTypeEClass = createEClass(FROM_ACTION_TYPE);
-		createEAttribute(fromActionTypeEClass, FROM_ACTION_TYPE__TEXT_CONTENT);
-		createEAttribute(fromActionTypeEClass, FROM_ACTION_TYPE__ID);
-
-		fromOutcomeTypeEClass = createEClass(FROM_OUTCOME_TYPE);
-		createEAttribute(fromOutcomeTypeEClass, FROM_OUTCOME_TYPE__TEXT_CONTENT);
-		createEAttribute(fromOutcomeTypeEClass, FROM_OUTCOME_TYPE__ID);
-
-		fromViewIdTypeEClass = createEClass(FROM_VIEW_ID_TYPE);
-		createEAttribute(fromViewIdTypeEClass, FROM_VIEW_ID_TYPE__TEXT_CONTENT);
-		createEAttribute(fromViewIdTypeEClass, FROM_VIEW_ID_TYPE__ID);
-
-		iconTypeEClass = createEClass(ICON_TYPE);
-		createEReference(iconTypeEClass, ICON_TYPE__SMALL_ICON);
-		createEReference(iconTypeEClass, ICON_TYPE__LARGE_ICON);
-		createEAttribute(iconTypeEClass, ICON_TYPE__LANG);
-		createEAttribute(iconTypeEClass, ICON_TYPE__ID);
-
-		ifTypeEClass = createEClass(IF_TYPE);
-		createEAttribute(ifTypeEClass, IF_TYPE__TEXT_CONTENT);
-		createEAttribute(ifTypeEClass, IF_TYPE__ID);
-
-		keyClassTypeEClass = createEClass(KEY_CLASS_TYPE);
-		createEAttribute(keyClassTypeEClass, KEY_CLASS_TYPE__TEXT_CONTENT);
-		createEAttribute(keyClassTypeEClass, KEY_CLASS_TYPE__ID);
-
-		keyTypeEClass = createEClass(KEY_TYPE);
-		createEAttribute(keyTypeEClass, KEY_TYPE__TEXT_CONTENT);
-		createEAttribute(keyTypeEClass, KEY_TYPE__ID);
-
-		largeIconTypeEClass = createEClass(LARGE_ICON_TYPE);
-		createEAttribute(largeIconTypeEClass, LARGE_ICON_TYPE__TEXT_CONTENT);
-		createEAttribute(largeIconTypeEClass, LARGE_ICON_TYPE__ID);
-
-		lifecycleFactoryTypeEClass = createEClass(LIFECYCLE_FACTORY_TYPE);
-		createEAttribute(lifecycleFactoryTypeEClass, LIFECYCLE_FACTORY_TYPE__TEXT_CONTENT);
-		createEAttribute(lifecycleFactoryTypeEClass, LIFECYCLE_FACTORY_TYPE__ID);
-
-		lifecycleTypeEClass = createEClass(LIFECYCLE_TYPE);
-		createEReference(lifecycleTypeEClass, LIFECYCLE_TYPE__PHASE_LISTENER);
-		createEReference(lifecycleTypeEClass, LIFECYCLE_TYPE__LIFECYCLE_EXTENSION);
-		createEAttribute(lifecycleTypeEClass, LIFECYCLE_TYPE__ID);
-
-		lifecycleExtensionTypeEClass = createEClass(LIFECYCLE_EXTENSION_TYPE);
-
-		listEntriesTypeEClass = createEClass(LIST_ENTRIES_TYPE);
-		createEReference(listEntriesTypeEClass, LIST_ENTRIES_TYPE__VALUE_CLASS);
-		createEReference(listEntriesTypeEClass, LIST_ENTRIES_TYPE__NULL_VALUE);
-		createEReference(listEntriesTypeEClass, LIST_ENTRIES_TYPE__VALUE);
-		createEAttribute(listEntriesTypeEClass, LIST_ENTRIES_TYPE__ID);
-
-		localeConfigTypeEClass = createEClass(LOCALE_CONFIG_TYPE);
-		createEReference(localeConfigTypeEClass, LOCALE_CONFIG_TYPE__DEFAULT_LOCALE);
-		createEReference(localeConfigTypeEClass, LOCALE_CONFIG_TYPE__SUPPORTED_LOCALE);
-		createEAttribute(localeConfigTypeEClass, LOCALE_CONFIG_TYPE__ID);
-
-		managedBeanClassTypeEClass = createEClass(MANAGED_BEAN_CLASS_TYPE);
-		createEAttribute(managedBeanClassTypeEClass, MANAGED_BEAN_CLASS_TYPE__TEXT_CONTENT);
-		createEAttribute(managedBeanClassTypeEClass, MANAGED_BEAN_CLASS_TYPE__ID);
-
-		managedBeanNameTypeEClass = createEClass(MANAGED_BEAN_NAME_TYPE);
-		createEAttribute(managedBeanNameTypeEClass, MANAGED_BEAN_NAME_TYPE__TEXT_CONTENT);
-		createEAttribute(managedBeanNameTypeEClass, MANAGED_BEAN_NAME_TYPE__ID);
-
-		managedBeanScopeTypeEClass = createEClass(MANAGED_BEAN_SCOPE_TYPE);
-		createEAttribute(managedBeanScopeTypeEClass, MANAGED_BEAN_SCOPE_TYPE__TEXT_CONTENT);
-		createEAttribute(managedBeanScopeTypeEClass, MANAGED_BEAN_SCOPE_TYPE__ID);
-
-		managedBeanTypeEClass = createEClass(MANAGED_BEAN_TYPE);
-		createEReference(managedBeanTypeEClass, MANAGED_BEAN_TYPE__DESCRIPTION);
-		createEReference(managedBeanTypeEClass, MANAGED_BEAN_TYPE__DISPLAY_NAME);
-		createEReference(managedBeanTypeEClass, MANAGED_BEAN_TYPE__ICON);
-		createEReference(managedBeanTypeEClass, MANAGED_BEAN_TYPE__MANAGED_BEAN_NAME);
-		createEReference(managedBeanTypeEClass, MANAGED_BEAN_TYPE__MANAGED_BEAN_CLASS);
-		createEReference(managedBeanTypeEClass, MANAGED_BEAN_TYPE__MANAGED_BEAN_SCOPE);
-		createEReference(managedBeanTypeEClass, MANAGED_BEAN_TYPE__MANAGED_PROPERTY);
-		createEReference(managedBeanTypeEClass, MANAGED_BEAN_TYPE__MAP_ENTRIES);
-		createEReference(managedBeanTypeEClass, MANAGED_BEAN_TYPE__LIST_ENTRIES);
-		createEReference(managedBeanTypeEClass, MANAGED_BEAN_TYPE__MANAGED_BEAN_EXTENSION);
-		createEAttribute(managedBeanTypeEClass, MANAGED_BEAN_TYPE__ID);
-		createEAttribute(managedBeanTypeEClass, MANAGED_BEAN_TYPE__EAGER);
-
-		managedBeanExtensionTypeEClass = createEClass(MANAGED_BEAN_EXTENSION_TYPE);
-
-		managedPropertyTypeEClass = createEClass(MANAGED_PROPERTY_TYPE);
-		createEReference(managedPropertyTypeEClass, MANAGED_PROPERTY_TYPE__DESCRIPTION);
-		createEReference(managedPropertyTypeEClass, MANAGED_PROPERTY_TYPE__DISPLAY_NAME);
-		createEReference(managedPropertyTypeEClass, MANAGED_PROPERTY_TYPE__ICON);
-		createEReference(managedPropertyTypeEClass, MANAGED_PROPERTY_TYPE__PROPERTY_NAME);
-		createEReference(managedPropertyTypeEClass, MANAGED_PROPERTY_TYPE__PROPERTY_CLASS);
-		createEReference(managedPropertyTypeEClass, MANAGED_PROPERTY_TYPE__MAP_ENTRIES);
-		createEReference(managedPropertyTypeEClass, MANAGED_PROPERTY_TYPE__NULL_VALUE);
-		createEReference(managedPropertyTypeEClass, MANAGED_PROPERTY_TYPE__VALUE);
-		createEReference(managedPropertyTypeEClass, MANAGED_PROPERTY_TYPE__LIST_ENTRIES);
-		createEAttribute(managedPropertyTypeEClass, MANAGED_PROPERTY_TYPE__ID);
-
-		mapEntriesTypeEClass = createEClass(MAP_ENTRIES_TYPE);
-		createEReference(mapEntriesTypeEClass, MAP_ENTRIES_TYPE__KEY_CLASS);
-		createEReference(mapEntriesTypeEClass, MAP_ENTRIES_TYPE__VALUE_CLASS);
-		createEReference(mapEntriesTypeEClass, MAP_ENTRIES_TYPE__MAP_ENTRY);
-		createEAttribute(mapEntriesTypeEClass, MAP_ENTRIES_TYPE__ID);
-
-		mapEntryTypeEClass = createEClass(MAP_ENTRY_TYPE);
-		createEReference(mapEntryTypeEClass, MAP_ENTRY_TYPE__KEY);
-		createEReference(mapEntryTypeEClass, MAP_ENTRY_TYPE__NULL_VALUE);
-		createEReference(mapEntryTypeEClass, MAP_ENTRY_TYPE__VALUE);
-		createEAttribute(mapEntryTypeEClass, MAP_ENTRY_TYPE__ID);
-
-		messageBundleTypeEClass = createEClass(MESSAGE_BUNDLE_TYPE);
-		createEAttribute(messageBundleTypeEClass, MESSAGE_BUNDLE_TYPE__TEXT_CONTENT);
-		createEAttribute(messageBundleTypeEClass, MESSAGE_BUNDLE_TYPE__ID);
-
-		nameTypeEClass = createEClass(NAME_TYPE);
-		createEAttribute(nameTypeEClass, NAME_TYPE__TEXT_CONTENT);
-		createEAttribute(nameTypeEClass, NAME_TYPE__ID);
-
-		navigationCaseTypeEClass = createEClass(NAVIGATION_CASE_TYPE);
-		createEReference(navigationCaseTypeEClass, NAVIGATION_CASE_TYPE__DESCRIPTION);
-		createEReference(navigationCaseTypeEClass, NAVIGATION_CASE_TYPE__DISPLAY_NAME);
-		createEReference(navigationCaseTypeEClass, NAVIGATION_CASE_TYPE__ICON);
-		createEReference(navigationCaseTypeEClass, NAVIGATION_CASE_TYPE__FROM_ACTION);
-		createEReference(navigationCaseTypeEClass, NAVIGATION_CASE_TYPE__FROM_OUTCOME);
-		createEReference(navigationCaseTypeEClass, NAVIGATION_CASE_TYPE__IF);
-		createEReference(navigationCaseTypeEClass, NAVIGATION_CASE_TYPE__TO_VIEW_ID);
-		createEReference(navigationCaseTypeEClass, NAVIGATION_CASE_TYPE__REDIRECT);
-		createEAttribute(navigationCaseTypeEClass, NAVIGATION_CASE_TYPE__ID);
-
-		navigationHandlerTypeEClass = createEClass(NAVIGATION_HANDLER_TYPE);
-		createEAttribute(navigationHandlerTypeEClass, NAVIGATION_HANDLER_TYPE__TEXT_CONTENT);
-		createEAttribute(navigationHandlerTypeEClass, NAVIGATION_HANDLER_TYPE__ID);
-
-		navigationRuleTypeEClass = createEClass(NAVIGATION_RULE_TYPE);
-		createEReference(navigationRuleTypeEClass, NAVIGATION_RULE_TYPE__DESCRIPTION);
-		createEReference(navigationRuleTypeEClass, NAVIGATION_RULE_TYPE__DISPLAY_NAME);
-		createEReference(navigationRuleTypeEClass, NAVIGATION_RULE_TYPE__ICON);
-		createEReference(navigationRuleTypeEClass, NAVIGATION_RULE_TYPE__FROM_VIEW_ID);
-		createEReference(navigationRuleTypeEClass, NAVIGATION_RULE_TYPE__NAVIGATION_CASE);
-		createEReference(navigationRuleTypeEClass, NAVIGATION_RULE_TYPE__NAVIGATION_RULE_EXTENSION);
-		createEAttribute(navigationRuleTypeEClass, NAVIGATION_RULE_TYPE__ID);
-
-		navigationRuleExtensionTypeEClass = createEClass(NAVIGATION_RULE_EXTENSION_TYPE);
-
-		nullValueTypeEClass = createEClass(NULL_VALUE_TYPE);
-		createEAttribute(nullValueTypeEClass, NULL_VALUE_TYPE__ID);
-
-		orderingTypeEClass = createEClass(ORDERING_TYPE);
-		createEReference(orderingTypeEClass, ORDERING_TYPE__BEFORE);
-		createEReference(orderingTypeEClass, ORDERING_TYPE__AFTER);
-
-		orderingOrderingTypeEClass = createEClass(ORDERING_ORDERING_TYPE);
-		createEReference(orderingOrderingTypeEClass, ORDERING_ORDERING_TYPE__NAME);
-		createEReference(orderingOrderingTypeEClass, ORDERING_ORDERING_TYPE__OTHERS);
-
-		orderingOthersTypeEClass = createEClass(ORDERING_OTHERS_TYPE);
-		createEAttribute(orderingOthersTypeEClass, ORDERING_OTHERS_TYPE__ID);
-
-		partialViewContextFactoryTypeEClass = createEClass(PARTIAL_VIEW_CONTEXT_FACTORY_TYPE);
-		createEAttribute(partialViewContextFactoryTypeEClass, PARTIAL_VIEW_CONTEXT_FACTORY_TYPE__TEXT_CONTENT);
-		createEAttribute(partialViewContextFactoryTypeEClass, PARTIAL_VIEW_CONTEXT_FACTORY_TYPE__ID);
-
-		phaseListenerTypeEClass = createEClass(PHASE_LISTENER_TYPE);
-		createEAttribute(phaseListenerTypeEClass, PHASE_LISTENER_TYPE__TEXT_CONTENT);
-		createEAttribute(phaseListenerTypeEClass, PHASE_LISTENER_TYPE__ID);
-
-		propertyClassTypeEClass = createEClass(PROPERTY_CLASS_TYPE);
-		createEAttribute(propertyClassTypeEClass, PROPERTY_CLASS_TYPE__TEXT_CONTENT);
-		createEAttribute(propertyClassTypeEClass, PROPERTY_CLASS_TYPE__ID);
-
-		propertyExtensionTypeEClass = createEClass(PROPERTY_EXTENSION_TYPE);
-
-		propertyNameTypeEClass = createEClass(PROPERTY_NAME_TYPE);
-		createEAttribute(propertyNameTypeEClass, PROPERTY_NAME_TYPE__TEXT_CONTENT);
-		createEAttribute(propertyNameTypeEClass, PROPERTY_NAME_TYPE__ID);
-
-		propertyResolverTypeEClass = createEClass(PROPERTY_RESOLVER_TYPE);
-		createEAttribute(propertyResolverTypeEClass, PROPERTY_RESOLVER_TYPE__TEXT_CONTENT);
-		createEAttribute(propertyResolverTypeEClass, PROPERTY_RESOLVER_TYPE__ID);
-
-		propertyTypeEClass = createEClass(PROPERTY_TYPE);
-		createEReference(propertyTypeEClass, PROPERTY_TYPE__DESCRIPTION);
-		createEReference(propertyTypeEClass, PROPERTY_TYPE__DISPLAY_NAME);
-		createEReference(propertyTypeEClass, PROPERTY_TYPE__ICON);
-		createEReference(propertyTypeEClass, PROPERTY_TYPE__PROPERTY_NAME);
-		createEReference(propertyTypeEClass, PROPERTY_TYPE__PROPERTY_CLASS);
-		createEReference(propertyTypeEClass, PROPERTY_TYPE__DEFAULT_VALUE);
-		createEReference(propertyTypeEClass, PROPERTY_TYPE__SUGGESTED_VALUE);
-		createEReference(propertyTypeEClass, PROPERTY_TYPE__PROPERTY_EXTENSION);
-		createEAttribute(propertyTypeEClass, PROPERTY_TYPE__ID);
-
-		redirectTypeEClass = createEClass(REDIRECT_TYPE);
-		createEReference(redirectTypeEClass, REDIRECT_TYPE__VIEW_PARAM);
-		createEAttribute(redirectTypeEClass, REDIRECT_TYPE__ID);
-		createEAttribute(redirectTypeEClass, REDIRECT_TYPE__INCLUDE_VIEW_PARAMS);
-
-		redirectViewParamTypeEClass = createEClass(REDIRECT_VIEW_PARAM_TYPE);
-		createEReference(redirectViewParamTypeEClass, REDIRECT_VIEW_PARAM_TYPE__NAME);
-		createEReference(redirectViewParamTypeEClass, REDIRECT_VIEW_PARAM_TYPE__VALUE);
-		createEAttribute(redirectViewParamTypeEClass, REDIRECT_VIEW_PARAM_TYPE__ID);
-
-		referencedBeanClassTypeEClass = createEClass(REFERENCED_BEAN_CLASS_TYPE);
-		createEAttribute(referencedBeanClassTypeEClass, REFERENCED_BEAN_CLASS_TYPE__TEXT_CONTENT);
-		createEAttribute(referencedBeanClassTypeEClass, REFERENCED_BEAN_CLASS_TYPE__ID);
-
-		referencedBeanNameTypeEClass = createEClass(REFERENCED_BEAN_NAME_TYPE);
-		createEAttribute(referencedBeanNameTypeEClass, REFERENCED_BEAN_NAME_TYPE__TEXT_CONTENT);
-		createEAttribute(referencedBeanNameTypeEClass, REFERENCED_BEAN_NAME_TYPE__ID);
-
-		referencedBeanTypeEClass = createEClass(REFERENCED_BEAN_TYPE);
-		createEReference(referencedBeanTypeEClass, REFERENCED_BEAN_TYPE__DESCRIPTION);
-		createEReference(referencedBeanTypeEClass, REFERENCED_BEAN_TYPE__DISPLAY_NAME);
-		createEReference(referencedBeanTypeEClass, REFERENCED_BEAN_TYPE__ICON);
-		createEReference(referencedBeanTypeEClass, REFERENCED_BEAN_TYPE__REFERENCED_BEAN_NAME);
-		createEReference(referencedBeanTypeEClass, REFERENCED_BEAN_TYPE__REFERENCED_BEAN_CLASS);
-		createEAttribute(referencedBeanTypeEClass, REFERENCED_BEAN_TYPE__ID);
-
-		rendererClassTypeEClass = createEClass(RENDERER_CLASS_TYPE);
-		createEAttribute(rendererClassTypeEClass, RENDERER_CLASS_TYPE__TEXT_CONTENT);
-		createEAttribute(rendererClassTypeEClass, RENDERER_CLASS_TYPE__ID);
-
-		rendererExtensionTypeEClass = createEClass(RENDERER_EXTENSION_TYPE);
-
-		rendererTypeEClass = createEClass(RENDERER_TYPE);
-		createEReference(rendererTypeEClass, RENDERER_TYPE__DESCRIPTION);
-		createEReference(rendererTypeEClass, RENDERER_TYPE__DISPLAY_NAME);
-		createEReference(rendererTypeEClass, RENDERER_TYPE__ICON);
-		createEReference(rendererTypeEClass, RENDERER_TYPE__COMPONENT_FAMILY);
-		createEReference(rendererTypeEClass, RENDERER_TYPE__RENDERER_TYPE);
-		createEReference(rendererTypeEClass, RENDERER_TYPE__RENDERER_CLASS);
-		createEReference(rendererTypeEClass, RENDERER_TYPE__FACET);
-		createEReference(rendererTypeEClass, RENDERER_TYPE__ATTRIBUTE);
-		createEReference(rendererTypeEClass, RENDERER_TYPE__RENDERER_EXTENSION);
-		createEAttribute(rendererTypeEClass, RENDERER_TYPE__ID);
-
-		rendererTypeTypeEClass = createEClass(RENDERER_TYPE_TYPE);
-		createEAttribute(rendererTypeTypeEClass, RENDERER_TYPE_TYPE__TEXT_CONTENT);
-		createEAttribute(rendererTypeTypeEClass, RENDERER_TYPE_TYPE__ID);
-
-		renderKitClassTypeEClass = createEClass(RENDER_KIT_CLASS_TYPE);
-		createEAttribute(renderKitClassTypeEClass, RENDER_KIT_CLASS_TYPE__TEXT_CONTENT);
-		createEAttribute(renderKitClassTypeEClass, RENDER_KIT_CLASS_TYPE__ID);
-
-		renderKitFactoryTypeEClass = createEClass(RENDER_KIT_FACTORY_TYPE);
-		createEAttribute(renderKitFactoryTypeEClass, RENDER_KIT_FACTORY_TYPE__TEXT_CONTENT);
-		createEAttribute(renderKitFactoryTypeEClass, RENDER_KIT_FACTORY_TYPE__ID);
-
-		renderKitIdTypeEClass = createEClass(RENDER_KIT_ID_TYPE);
-		createEAttribute(renderKitIdTypeEClass, RENDER_KIT_ID_TYPE__TEXT_CONTENT);
-		createEAttribute(renderKitIdTypeEClass, RENDER_KIT_ID_TYPE__ID);
-
-		renderKitTypeEClass = createEClass(RENDER_KIT_TYPE);
-		createEReference(renderKitTypeEClass, RENDER_KIT_TYPE__DESCRIPTION);
-		createEReference(renderKitTypeEClass, RENDER_KIT_TYPE__DISPLAY_NAME);
-		createEReference(renderKitTypeEClass, RENDER_KIT_TYPE__ICON);
-		createEReference(renderKitTypeEClass, RENDER_KIT_TYPE__RENDER_KIT_ID);
-		createEReference(renderKitTypeEClass, RENDER_KIT_TYPE__RENDER_KIT_CLASS);
-		createEReference(renderKitTypeEClass, RENDER_KIT_TYPE__RENDERER);
-		createEReference(renderKitTypeEClass, RENDER_KIT_TYPE__CLIENT_BEHAVIOR_RENDERER);
-		createEReference(renderKitTypeEClass, RENDER_KIT_TYPE__RENDER_KIT_EXTENSION);
-		createEAttribute(renderKitTypeEClass, RENDER_KIT_TYPE__ID);
-
-		renderKitExtensionTypeEClass = createEClass(RENDER_KIT_EXTENSION_TYPE);
-
-		resourceHandlerTypeEClass = createEClass(RESOURCE_HANDLER_TYPE);
-		createEAttribute(resourceHandlerTypeEClass, RESOURCE_HANDLER_TYPE__TEXT_CONTENT);
-		createEAttribute(resourceHandlerTypeEClass, RESOURCE_HANDLER_TYPE__ID);
-
-		smallIconTypeEClass = createEClass(SMALL_ICON_TYPE);
-		createEAttribute(smallIconTypeEClass, SMALL_ICON_TYPE__TEXT_CONTENT);
-		createEAttribute(smallIconTypeEClass, SMALL_ICON_TYPE__ID);
-
-		sourceClassTypeEClass = createEClass(SOURCE_CLASS_TYPE);
-		createEAttribute(sourceClassTypeEClass, SOURCE_CLASS_TYPE__TEXT_CONTENT);
-		createEAttribute(sourceClassTypeEClass, SOURCE_CLASS_TYPE__ID);
-
-		stateManagerTypeEClass = createEClass(STATE_MANAGER_TYPE);
-		createEAttribute(stateManagerTypeEClass, STATE_MANAGER_TYPE__TEXT_CONTENT);
-		createEAttribute(stateManagerTypeEClass, STATE_MANAGER_TYPE__ID);
-
-		suggestedValueTypeEClass = createEClass(SUGGESTED_VALUE_TYPE);
-		createEAttribute(suggestedValueTypeEClass, SUGGESTED_VALUE_TYPE__TEXT_CONTENT);
-		createEAttribute(suggestedValueTypeEClass, SUGGESTED_VALUE_TYPE__ID);
-
-		supportedLocaleTypeEClass = createEClass(SUPPORTED_LOCALE_TYPE);
-		createEAttribute(supportedLocaleTypeEClass, SUPPORTED_LOCALE_TYPE__TEXT_CONTENT);
-		createEAttribute(supportedLocaleTypeEClass, SUPPORTED_LOCALE_TYPE__ID);
-
-		systemEventClassTypeEClass = createEClass(SYSTEM_EVENT_CLASS_TYPE);
-		createEAttribute(systemEventClassTypeEClass, SYSTEM_EVENT_CLASS_TYPE__TEXT_CONTENT);
-		createEAttribute(systemEventClassTypeEClass, SYSTEM_EVENT_CLASS_TYPE__ID);
-
-		systemEventListenerClassTypeEClass = createEClass(SYSTEM_EVENT_LISTENER_CLASS_TYPE);
-		createEAttribute(systemEventListenerClassTypeEClass, SYSTEM_EVENT_LISTENER_CLASS_TYPE__TEXT_CONTENT);
-		createEAttribute(systemEventListenerClassTypeEClass, SYSTEM_EVENT_LISTENER_CLASS_TYPE__ID);
-
-		systemEventListenerTypeEClass = createEClass(SYSTEM_EVENT_LISTENER_TYPE);
-		createEReference(systemEventListenerTypeEClass, SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_LISTENER_CLASS);
-		createEReference(systemEventListenerTypeEClass, SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_CLASS);
-		createEReference(systemEventListenerTypeEClass, SYSTEM_EVENT_LISTENER_TYPE__SOURCE_CLASS);
-		createEAttribute(systemEventListenerTypeEClass, SYSTEM_EVENT_LISTENER_TYPE__ID);
-
-		tagHandlerDelegateFactoryTypeEClass = createEClass(TAG_HANDLER_DELEGATE_FACTORY_TYPE);
-		createEAttribute(tagHandlerDelegateFactoryTypeEClass, TAG_HANDLER_DELEGATE_FACTORY_TYPE__TEXT_CONTENT);
-		createEAttribute(tagHandlerDelegateFactoryTypeEClass, TAG_HANDLER_DELEGATE_FACTORY_TYPE__ID);
-
-		toViewIdTypeEClass = createEClass(TO_VIEW_ID_TYPE);
-		createEAttribute(toViewIdTypeEClass, TO_VIEW_ID_TYPE__TEXT_CONTENT);
-		createEAttribute(toViewIdTypeEClass, TO_VIEW_ID_TYPE__ID);
-
-		validatorClassTypeEClass = createEClass(VALIDATOR_CLASS_TYPE);
-		createEAttribute(validatorClassTypeEClass, VALIDATOR_CLASS_TYPE__TEXT_CONTENT);
-		createEAttribute(validatorClassTypeEClass, VALIDATOR_CLASS_TYPE__ID);
-
-		validatorIdTypeEClass = createEClass(VALIDATOR_ID_TYPE);
-		createEAttribute(validatorIdTypeEClass, VALIDATOR_ID_TYPE__TEXT_CONTENT);
-		createEAttribute(validatorIdTypeEClass, VALIDATOR_ID_TYPE__ID);
-
-		validatorTypeEClass = createEClass(VALIDATOR_TYPE);
-		createEReference(validatorTypeEClass, VALIDATOR_TYPE__DESCRIPTION);
-		createEReference(validatorTypeEClass, VALIDATOR_TYPE__DISPLAY_NAME);
-		createEReference(validatorTypeEClass, VALIDATOR_TYPE__ICON);
-		createEReference(validatorTypeEClass, VALIDATOR_TYPE__VALIDATOR_ID);
-		createEReference(validatorTypeEClass, VALIDATOR_TYPE__VALIDATOR_CLASS);
-		createEReference(validatorTypeEClass, VALIDATOR_TYPE__ATTRIBUTE);
-		createEReference(validatorTypeEClass, VALIDATOR_TYPE__PROPERTY);
-		createEReference(validatorTypeEClass, VALIDATOR_TYPE__VALIDATOR_EXTENSION);
-		createEAttribute(validatorTypeEClass, VALIDATOR_TYPE__ID);
-
-		validatorExtensionTypeEClass = createEClass(VALIDATOR_EXTENSION_TYPE);
-
-		valueClassTypeEClass = createEClass(VALUE_CLASS_TYPE);
-		createEAttribute(valueClassTypeEClass, VALUE_CLASS_TYPE__TEXT_CONTENT);
-		createEAttribute(valueClassTypeEClass, VALUE_CLASS_TYPE__ID);
-
-		valueTypeEClass = createEClass(VALUE_TYPE);
-		createEAttribute(valueTypeEClass, VALUE_TYPE__TEXT_CONTENT);
-		createEAttribute(valueTypeEClass, VALUE_TYPE__ID);
-
-		variableResolverTypeEClass = createEClass(VARIABLE_RESOLVER_TYPE);
-		createEAttribute(variableResolverTypeEClass, VARIABLE_RESOLVER_TYPE__TEXT_CONTENT);
-		createEAttribute(variableResolverTypeEClass, VARIABLE_RESOLVER_TYPE__ID);
-
-		viewHandlerTypeEClass = createEClass(VIEW_HANDLER_TYPE);
-		createEAttribute(viewHandlerTypeEClass, VIEW_HANDLER_TYPE__TEXT_CONTENT);
-		createEAttribute(viewHandlerTypeEClass, VIEW_HANDLER_TYPE__ID);
-
-		resourceBundleTypeEClass = createEClass(RESOURCE_BUNDLE_TYPE);
-		createEReference(resourceBundleTypeEClass, RESOURCE_BUNDLE_TYPE__DESCRIPTION);
-		createEReference(resourceBundleTypeEClass, RESOURCE_BUNDLE_TYPE__DISPLAY_NAME);
-		createEReference(resourceBundleTypeEClass, RESOURCE_BUNDLE_TYPE__ICON);
-		createEReference(resourceBundleTypeEClass, RESOURCE_BUNDLE_TYPE__BASE_NAME);
-		createEReference(resourceBundleTypeEClass, RESOURCE_BUNDLE_TYPE__VAR);
-		createEAttribute(resourceBundleTypeEClass, RESOURCE_BUNDLE_TYPE__ID);
-
-		baseNameTypeEClass = createEClass(BASE_NAME_TYPE);
-		createEAttribute(baseNameTypeEClass, BASE_NAME_TYPE__TEXT_CONTENT);
-		createEAttribute(baseNameTypeEClass, BASE_NAME_TYPE__ID);
-
-		varTypeEClass = createEClass(VAR_TYPE);
-		createEAttribute(varTypeEClass, VAR_TYPE__TEXT_CONTENT);
-		createEAttribute(varTypeEClass, VAR_TYPE__ID);
-
-		viewDeclarationLanguageFactoryTypeEClass = createEClass(VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE);
-		createEAttribute(viewDeclarationLanguageFactoryTypeEClass, VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE__TEXT_CONTENT);
-		createEAttribute(viewDeclarationLanguageFactoryTypeEClass, VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE__ID);
-
-		visitContextFactoryTypeEClass = createEClass(VISIT_CONTEXT_FACTORY_TYPE);
-		createEAttribute(visitContextFactoryTypeEClass, VISIT_CONTEXT_FACTORY_TYPE__TEXT_CONTENT);
-		createEAttribute(visitContextFactoryTypeEClass, VISIT_CONTEXT_FACTORY_TYPE__ID);
-	}
-
-    /**
-	 * <!-- 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);
-
-		// Obtain other dependent packages
-		XMLTypePackage theXMLTypePackage = (XMLTypePackage)EPackage.Registry.INSTANCE.getEPackage(XMLTypePackage.eNS_URI);
-
-		// Add supertypes to classes
-		applicationExtensionTypeEClass.getESuperTypes().add(this.getExtensionType());
-		attributeExtensionTypeEClass.getESuperTypes().add(this.getExtensionType());
-		behaviorExtensionTypeEClass.getESuperTypes().add(this.getExtensionType());
-		componentExtensionTypeEClass.getESuperTypes().add(this.getExtensionType());
-		converterExtensionTypeEClass.getESuperTypes().add(this.getExtensionType());
-		facesConfigExtensionTypeEClass.getESuperTypes().add(this.getExtensionType());
-		facetExtensionTypeEClass.getESuperTypes().add(this.getExtensionType());
-		factoryExtensionTypeEClass.getESuperTypes().add(this.getExtensionType());
-		lifecycleExtensionTypeEClass.getESuperTypes().add(this.getExtensionType());
-		managedBeanExtensionTypeEClass.getESuperTypes().add(this.getExtensionType());
-		navigationRuleExtensionTypeEClass.getESuperTypes().add(this.getExtensionType());
-		propertyExtensionTypeEClass.getESuperTypes().add(this.getExtensionType());
-		rendererExtensionTypeEClass.getESuperTypes().add(this.getExtensionType());
-		renderKitExtensionTypeEClass.getESuperTypes().add(this.getExtensionType());
-		validatorExtensionTypeEClass.getESuperTypes().add(this.getExtensionType());
-
-		// Initialize classes and features; add operations and parameters
-		initEClass(absoluteOrderingTypeEClass, AbsoluteOrderingType.class, "AbsoluteOrderingType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getAbsoluteOrderingType_Name(), this.getNameType(), null, "name", null, 0, -1, AbsoluteOrderingType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getAbsoluteOrderingType_Others(), this.getOrderingOthersType(), null, "others", null, 0, 1, AbsoluteOrderingType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(actionListenerTypeEClass, ActionListenerType.class, "ActionListenerType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getActionListenerType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ActionListenerType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getActionListenerType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ActionListenerType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(applicationFactoryTypeEClass, ApplicationFactoryType.class, "ApplicationFactoryType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getApplicationFactoryType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ApplicationFactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getApplicationFactoryType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ApplicationFactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(applicationTypeEClass, ApplicationType.class, "ApplicationType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getApplicationType_ActionListener(), this.getActionListenerType(), null, "actionListener", null, 0, -1, ApplicationType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getApplicationType_DefaultRenderKitId(), this.getDefaultRenderKitIdType(), null, "defaultRenderKitId", null, 0, -1, ApplicationType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getApplicationType_MessageBundle(), this.getMessageBundleType(), null, "messageBundle", null, 0, -1, ApplicationType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getApplicationType_NavigationHandler(), this.getNavigationHandlerType(), null, "navigationHandler", null, 0, -1, ApplicationType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getApplicationType_ViewHandler(), this.getViewHandlerType(), null, "viewHandler", null, 0, -1, ApplicationType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getApplicationType_StateManager(), this.getStateManagerType(), null, "stateManager", null, 0, -1, ApplicationType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getApplicationType_ELResolver(), this.getELResolverType(), null, "eLResolver", null, 0, -1, ApplicationType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getApplicationType_PropertyResolver(), this.getPropertyResolverType(), null, "propertyResolver", null, 0, -1, ApplicationType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getApplicationType_VariableResolver(), this.getVariableResolverType(), null, "variableResolver", null, 0, -1, ApplicationType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getApplicationType_ResourceHandler(), this.getResourceHandlerType(), null, "resourceHandler", null, 0, -1, ApplicationType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getApplicationType_SystemEventListener(), this.getSystemEventListenerType(), null, "systemEventListener", null, 0, -1, ApplicationType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getApplicationType_LocaleConfig(), this.getLocaleConfigType(), null, "localeConfig", null, 0, -1, ApplicationType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getApplicationType_ResourceBundle(), this.getResourceBundleType(), null, "resourceBundle", null, 0, -1, ApplicationType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getApplicationType_ApplicationExtension(), this.getApplicationExtensionType(), null, "applicationExtension", null, 0, -1, ApplicationType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getApplicationType_DefaultValidators(), this.getDefaultValidatorsType(), null, "defaultValidators", null, 0, -1, ApplicationType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getApplicationType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ApplicationType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(applicationExtensionTypeEClass, ApplicationExtensionType.class, "ApplicationExtensionType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(attributeClassTypeEClass, AttributeClassType.class, "AttributeClassType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getAttributeClassType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, AttributeClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getAttributeClassType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, AttributeClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(attributeExtensionTypeEClass, AttributeExtensionType.class, "AttributeExtensionType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(attributeNameTypeEClass, AttributeNameType.class, "AttributeNameType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getAttributeNameType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, AttributeNameType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getAttributeNameType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, AttributeNameType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(attributeTypeEClass, AttributeType.class, "AttributeType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getAttributeType_Description(), this.getDescriptionType(), null, "description", null, 0, -1, AttributeType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getAttributeType_DisplayName(), this.getDisplayNameType(), null, "displayName", null, 0, -1, AttributeType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getAttributeType_Icon(), this.getIconType(), null, "icon", null, 0, -1, AttributeType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getAttributeType_AttributeName(), this.getAttributeNameType(), null, "attributeName", null, 1, 1, AttributeType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getAttributeType_AttributeClass(), this.getAttributeClassType(), null, "attributeClass", null, 1, 1, AttributeType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getAttributeType_DefaultValue(), this.getDefaultValueType(), null, "defaultValue", null, 0, 1, AttributeType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getAttributeType_SuggestedValue(), this.getSuggestedValueType(), null, "suggestedValue", null, 0, 1, AttributeType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getAttributeType_AttributeExtension(), this.getAttributeExtensionType(), null, "attributeExtension", null, 0, -1, AttributeType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getAttributeType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, AttributeType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(behaviorClassTypeEClass, BehaviorClassType.class, "BehaviorClassType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getBehaviorClassType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, BehaviorClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getBehaviorClassType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, BehaviorClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(behaviorIdTypeEClass, BehaviorIdType.class, "BehaviorIdType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getBehaviorIdType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, BehaviorIdType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getBehaviorIdType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, BehaviorIdType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(behaviorTypeEClass, BehaviorType.class, "BehaviorType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getBehaviorType_Description(), this.getDescriptionType(), null, "description", null, 0, -1, BehaviorType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getBehaviorType_DisplayName(), this.getDisplayNameType(), null, "displayName", null, 0, -1, BehaviorType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getBehaviorType_Icon(), this.getIconType(), null, "icon", null, 0, -1, BehaviorType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getBehaviorType_BehaviorId(), this.getBehaviorIdType(), null, "behaviorId", null, 1, 1, BehaviorType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getBehaviorType_BehaviorClass(), this.getBehaviorClassType(), null, "behaviorClass", null, 1, 1, BehaviorType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getBehaviorType_Attribute(), this.getAttributeType(), null, "attribute", null, 0, -1, BehaviorType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getBehaviorType_Property(), this.getPropertyType(), null, "property", null, 0, -1, BehaviorType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getBehaviorType_BehaviorExtension(), this.getBehaviorExtensionType(), null, "behaviorExtension", null, 0, -1, BehaviorType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(behaviorExtensionTypeEClass, BehaviorExtensionType.class, "BehaviorExtensionType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(clientBehaviorRendererClassTypeEClass, ClientBehaviorRendererClassType.class, "ClientBehaviorRendererClassType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getClientBehaviorRendererClassType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ClientBehaviorRendererClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getClientBehaviorRendererClassType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ClientBehaviorRendererClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(clientBehaviorRendererTypeEClass, ClientBehaviorRendererType.class, "ClientBehaviorRendererType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getClientBehaviorRendererType_ClientBehaviorRendererType(), this.getClientBehaviorRendererTypeType(), null, "clientBehaviorRendererType", null, 1, 1, ClientBehaviorRendererType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getClientBehaviorRendererType_ClientBehaviorRendererClass(), this.getClientBehaviorRendererClassType(), null, "clientBehaviorRendererClass", null, 1, 1, ClientBehaviorRendererType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(clientBehaviorRendererTypeTypeEClass, ClientBehaviorRendererTypeType.class, "ClientBehaviorRendererTypeType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getClientBehaviorRendererTypeType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ClientBehaviorRendererTypeType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getClientBehaviorRendererTypeType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ClientBehaviorRendererTypeType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(componentClassTypeEClass, ComponentClassType.class, "ComponentClassType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getComponentClassType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ComponentClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getComponentClassType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ComponentClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(componentExtensionTypeEClass, ComponentExtensionType.class, "ComponentExtensionType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(componentFamilyTypeEClass, ComponentFamilyType.class, "ComponentFamilyType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getComponentFamilyType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ComponentFamilyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getComponentFamilyType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ComponentFamilyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(componentTypeEClass, ComponentType.class, "ComponentType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getComponentType_Description(), this.getDescriptionType(), null, "description", null, 0, -1, ComponentType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getComponentType_DisplayName(), this.getDisplayNameType(), null, "displayName", null, 0, -1, ComponentType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getComponentType_Icon(), this.getIconType(), null, "icon", null, 0, -1, ComponentType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getComponentType_ComponentType(), this.getComponentTypeType(), null, "componentType", null, 1, 1, ComponentType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getComponentType_ComponentClass(), this.getComponentClassType(), null, "componentClass", null, 1, 1, ComponentType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getComponentType_Facet(), this.getFacetType(), null, "facet", null, 0, -1, ComponentType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getComponentType_Attribute(), this.getAttributeType(), null, "attribute", null, 0, -1, ComponentType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getComponentType_Property(), this.getPropertyType(), null, "property", null, 0, -1, ComponentType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getComponentType_ComponentExtension(), this.getComponentExtensionType(), null, "componentExtension", null, 0, -1, ComponentType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getComponentType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ComponentType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(componentTypeTypeEClass, ComponentTypeType.class, "ComponentTypeType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getComponentTypeType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ComponentTypeType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getComponentTypeType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ComponentTypeType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(converterClassTypeEClass, ConverterClassType.class, "ConverterClassType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getConverterClassType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ConverterClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getConverterClassType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ConverterClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(converterForClassTypeEClass, ConverterForClassType.class, "ConverterForClassType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getConverterForClassType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ConverterForClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getConverterForClassType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ConverterForClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(converterIdTypeEClass, ConverterIdType.class, "ConverterIdType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getConverterIdType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ConverterIdType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getConverterIdType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ConverterIdType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(converterTypeEClass, ConverterType.class, "ConverterType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getConverterType_Description(), this.getDescriptionType(), null, "description", null, 0, -1, ConverterType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getConverterType_DisplayName(), this.getDisplayNameType(), null, "displayName", null, 0, -1, ConverterType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getConverterType_Icon(), this.getIconType(), null, "icon", null, 0, -1, ConverterType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getConverterType_ConverterId(), this.getConverterIdType(), null, "converterId", null, 0, 1, ConverterType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getConverterType_ConverterForClass(), this.getConverterForClassType(), null, "converterForClass", null, 0, 1, ConverterType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getConverterType_ConverterClass(), this.getConverterClassType(), null, "converterClass", null, 1, 1, ConverterType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getConverterType_Attribute(), this.getAttributeType(), null, "attribute", null, 0, -1, ConverterType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getConverterType_Property(), this.getPropertyType(), null, "property", null, 0, -1, ConverterType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getConverterType_ConverterExtension(), this.getConverterExtensionType(), null, "converterExtension", null, 0, -1, ConverterType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getConverterType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ConverterType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(converterExtensionTypeEClass, ConverterExtensionType.class, "ConverterExtensionType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(defaultLocaleTypeEClass, DefaultLocaleType.class, "DefaultLocaleType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getDefaultLocaleType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, DefaultLocaleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getDefaultLocaleType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, DefaultLocaleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(defaultRenderKitIdTypeEClass, DefaultRenderKitIdType.class, "DefaultRenderKitIdType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getDefaultRenderKitIdType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, DefaultRenderKitIdType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getDefaultRenderKitIdType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, DefaultRenderKitIdType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(defaultValidatorsTypeEClass, DefaultValidatorsType.class, "DefaultValidatorsType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getDefaultValidatorsType_ValidatorId(), this.getValidatorIdType(), null, "validatorId", null, 0, -1, DefaultValidatorsType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getDefaultValidatorsType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, DefaultValidatorsType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(defaultValueTypeEClass, DefaultValueType.class, "DefaultValueType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getDefaultValueType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, DefaultValueType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getDefaultValueType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, DefaultValueType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(descriptionTypeEClass, DescriptionType.class, "DescriptionType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getDescriptionType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, DescriptionType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getDescriptionType_Lang(), theXMLTypePackage.getLanguage(), "lang", null, 0, 1, DescriptionType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getDescriptionType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, DescriptionType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(displayNameTypeEClass, DisplayNameType.class, "DisplayNameType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getDisplayNameType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, DisplayNameType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getDisplayNameType_Lang(), theXMLTypePackage.getLanguage(), "lang", null, 0, 1, DisplayNameType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getDisplayNameType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, DisplayNameType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(documentRootEClass, DocumentRoot.class, "DocumentRoot", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getDocumentRoot_Mixed(), ecorePackage.getEFeatureMapEntry(), "mixed", null, 0, -1, null, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_XMLNSPrefixMap(), ecorePackage.getEStringToStringMapEntry(), null, "xMLNSPrefixMap", null, 0, -1, null, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_XSISchemaLocation(), ecorePackage.getEStringToStringMapEntry(), null, "xSISchemaLocation", null, 0, -1, null, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_AbsoluteOrdering(), this.getAbsoluteOrderingType(), null, "absoluteOrdering", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ActionListener(), this.getActionListenerType(), null, "actionListener", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_Application(), this.getApplicationType(), null, "application", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ApplicationFactory(), this.getApplicationFactoryType(), null, "applicationFactory", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_Attribute(), this.getAttributeType(), null, "attribute", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_AttributeClass(), this.getAttributeClassType(), null, "attributeClass", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_AttributeExtension(), this.getAttributeExtensionType(), null, "attributeExtension", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_AttributeName(), this.getAttributeNameType(), null, "attributeName", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_Behavior(), this.getBehaviorType(), null, "behavior", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_BehaviorClass(), this.getBehaviorClassType(), null, "behaviorClass", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_BehaviorId(), this.getBehaviorIdType(), null, "behaviorId", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_BehaviorExtension(), this.getBehaviorExtensionType(), null, "behaviorExtension", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_Component(), this.getComponentType(), null, "component", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ComponentClass(), this.getComponentClassType(), null, "componentClass", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ComponentExtension(), this.getComponentExtensionType(), null, "componentExtension", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ComponentFamily(), this.getComponentFamilyType(), null, "componentFamily", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ComponentType(), this.getComponentTypeType(), null, "componentType", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_Converter(), this.getConverterType(), null, "converter", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ConverterClass(), this.getConverterClassType(), null, "converterClass", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ConverterForClass(), this.getConverterForClassType(), null, "converterForClass", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ConverterId(), this.getConverterIdType(), null, "converterId", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_DefaultLocale(), this.getDefaultLocaleType(), null, "defaultLocale", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_DefaultRenderKitId(), this.getDefaultRenderKitIdType(), null, "defaultRenderKitId", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_DefaultValidators(), this.getDefaultValidatorsType(), null, "defaultValidators", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_DefaultValue(), this.getDefaultValueType(), null, "defaultValue", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_Description(), this.getDescriptionType(), null, "description", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_DisplayName(), this.getDisplayNameType(), null, "displayName", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ExceptionHandlerFactory(), this.getExceptionHandlerFactoryType(), null, "exceptionHandlerFactory", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ExternalContextFactory(), this.getExternalContextFactoryType(), null, "externalContextFactory", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_FacesConfig(), this.getFacesConfigType(), null, "facesConfig", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_FacesContextFactory(), this.getFacesContextFactoryType(), null, "facesContextFactory", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_Facet(), this.getFacetType(), null, "facet", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_FacetExtension(), this.getFacetExtensionType(), null, "facetExtension", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_FacetName(), this.getFacetNameType(), null, "facetName", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_Factory(), this.getFactoryType(), null, "factory", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_FromAction(), this.getFromActionType(), null, "fromAction", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_FromOutcome(), this.getFromOutcomeType(), null, "fromOutcome", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_FromViewId(), this.getFromViewIdType(), null, "fromViewId", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_Icon(), this.getIconType(), null, "icon", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_If(), this.getIfType(), null, "if", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_Key(), this.getKeyType(), null, "key", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_KeyClass(), this.getKeyClassType(), null, "keyClass", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_LargeIcon(), this.getLargeIconType(), null, "largeIcon", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_Lifecycle(), this.getLifecycleType(), null, "lifecycle", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_LifecycleFactory(), this.getLifecycleFactoryType(), null, "lifecycleFactory", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ListEntries(), this.getListEntriesType(), null, "listEntries", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_LocaleConfig(), this.getLocaleConfigType(), null, "localeConfig", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ManagedBean(), this.getManagedBeanType(), null, "managedBean", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ManagedBeanClass(), this.getManagedBeanClassType(), null, "managedBeanClass", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ManagedBeanName(), this.getManagedBeanNameType(), null, "managedBeanName", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ManagedBeanScope(), this.getManagedBeanScopeType(), null, "managedBeanScope", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ManagedProperty(), this.getManagedPropertyType(), null, "managedProperty", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_MapEntries(), this.getMapEntriesType(), null, "mapEntries", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_MapEntry(), this.getMapEntryType(), null, "mapEntry", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_MessageBundle(), this.getMessageBundleType(), null, "messageBundle", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_Name(), this.getNameType(), null, "name", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_NavigationCase(), this.getNavigationCaseType(), null, "navigationCase", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_NavigationHandler(), this.getNavigationHandlerType(), null, "navigationHandler", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_NavigationRule(), this.getNavigationRuleType(), null, "navigationRule", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_NullValue(), this.getNullValueType(), null, "nullValue", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_Ordering(), this.getOrderingType(), null, "ordering", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_OrderingOrdering(), this.getOrderingOrderingType(), null, "orderingOrdering", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_Others(), this.getOrderingOthersType(), null, "others", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_PartialViewContextFactory(), this.getPartialViewContextFactoryType(), null, "partialViewContextFactory", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_PhaseListener(), this.getPhaseListenerType(), null, "phaseListener", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_Property(), this.getPropertyType(), null, "property", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_PropertyClass(), this.getPropertyClassType(), null, "propertyClass", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_PropertyExtension(), this.getPropertyExtensionType(), null, "propertyExtension", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_PropertyName(), this.getPropertyNameType(), null, "propertyName", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_PropertyResolver(), this.getPropertyResolverType(), null, "propertyResolver", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_Redirect(), this.getRedirectType(), null, "redirect", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_RedirectViewParam(), this.getRedirectViewParamType(), null, "redirectViewParam", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ReferencedBean(), this.getReferencedBeanType(), null, "referencedBean", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ReferencedBeanClass(), this.getReferencedBeanClassType(), null, "referencedBeanClass", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ReferencedBeanName(), this.getReferencedBeanNameType(), null, "referencedBeanName", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_Renderer(), this.getRendererType(), null, "renderer", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_RendererClass(), this.getRendererClassType(), null, "rendererClass", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_RendererExtension(), this.getRendererExtensionType(), null, "rendererExtension", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_RendererType(), this.getRendererTypeType(), null, "rendererType", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_RenderKit(), this.getRenderKitType(), null, "renderKit", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_RenderKitClass(), this.getRenderKitClassType(), null, "renderKitClass", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_RenderKitFactory(), this.getRenderKitFactoryType(), null, "renderKitFactory", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_RenderKitId(), this.getRenderKitIdType(), null, "renderKitId", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ResourceHandler(), this.getResourceHandlerType(), null, "resourceHandler", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_SmallIcon(), this.getSmallIconType(), null, "smallIcon", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_SourceClass(), this.getSourceClassType(), null, "sourceClass", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_StateManager(), this.getStateManagerType(), null, "stateManager", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_SuggestedValue(), this.getSuggestedValueType(), null, "suggestedValue", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_SupportedLocale(), this.getSupportedLocaleType(), null, "supportedLocale", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_SystemEventClass(), this.getSystemEventClassType(), null, "systemEventClass", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_SystemEventListener(), this.getSystemEventListenerType(), null, "systemEventListener", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_SystemEventListenerClass(), this.getSystemEventListenerClassType(), null, "systemEventListenerClass", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_TagHandlerDelegateFactory(), this.getTagHandlerDelegateFactoryType(), null, "tagHandlerDelegateFactory", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ToViewId(), this.getToViewIdType(), null, "toViewId", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_Validator(), this.getValidatorType(), null, "validator", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ValidatorClass(), this.getValidatorClassType(), null, "validatorClass", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ValidatorId(), this.getValidatorIdType(), null, "validatorId", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_Value(), this.getValueType(), null, "value", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ValueClass(), this.getValueClassType(), null, "valueClass", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_VariableResolver(), this.getVariableResolverType(), null, "variableResolver", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ViewDeclarationLanguageFactory(), this.getViewDeclarationLanguageFactoryType(), null, "viewDeclarationLanguageFactory", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_ViewHandler(), this.getViewHandlerType(), null, "viewHandler", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-		initEReference(getDocumentRoot_VisitContextFactory(), this.getVisitContextFactoryType(), null, "visitContextFactory", null, 0, -2, null, IS_TRANSIENT, IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, IS_DERIVED, IS_ORDERED);
-
-		initEClass(dynamicAttributeEClass, DynamicAttribute.class, "DynamicAttribute", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getDynamicAttribute_Name(), ecorePackage.getEString(), "name", null, 0, 1, DynamicAttribute.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getDynamicAttribute_Value(), ecorePackage.getEString(), "value", null, 0, 1, DynamicAttribute.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(dynamicElementEClass, DynamicElement.class, "DynamicElement", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getDynamicElement_ChildNodes(), this.getDynamicElement(), null, "childNodes", null, 0, -1, DynamicElement.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getDynamicElement_Name(), ecorePackage.getEString(), "name", null, 0, 1, DynamicElement.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getDynamicElement_Attributes(), this.getDynamicAttribute(), null, "attributes", null, 0, -1, DynamicElement.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getDynamicElement_TextContent(), ecorePackage.getEString(), "textContent", null, 0, 1, DynamicElement.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(elResolverTypeEClass, ELResolverType.class, "ELResolverType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getELResolverType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ELResolverType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getELResolverType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ELResolverType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(exceptionHandlerFactoryTypeEClass, ExceptionHandlerFactoryType.class, "ExceptionHandlerFactoryType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getExceptionHandlerFactoryType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ExceptionHandlerFactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getExceptionHandlerFactoryType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ExceptionHandlerFactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(extensionTypeEClass, ExtensionType.class, "ExtensionType", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getExtensionType_ChildNodes(), this.getDynamicElement(), null, "childNodes", null, 0, -1, ExtensionType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getExtensionType_TextContent(), ecorePackage.getEString(), "textContent", null, 0, 1, ExtensionType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getExtensionType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ExtensionType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(externalContextFactoryTypeEClass, ExternalContextFactoryType.class, "ExternalContextFactoryType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getExternalContextFactoryType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ExternalContextFactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getExternalContextFactoryType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ExternalContextFactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(facesConfigTypeEClass, FacesConfigType.class, "FacesConfigType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getFacesConfigType_Application(), this.getApplicationType(), null, "application", null, 0, -1, FacesConfigType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFacesConfigType_Ordering(), this.getOrderingType(), null, "ordering", null, 0, -1, FacesConfigType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFacesConfigType_AbsoluteOrdering(), this.getAbsoluteOrderingType(), null, "absoluteOrdering", null, 0, 1, FacesConfigType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFacesConfigType_Factory(), this.getFactoryType(), null, "factory", null, 0, -1, FacesConfigType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFacesConfigType_Component(), this.getComponentType(), null, "component", null, 0, -1, FacesConfigType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFacesConfigType_Converter(), this.getConverterType(), null, "converter", null, 0, -1, FacesConfigType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFacesConfigType_ManagedBean(), this.getManagedBeanType(), null, "managedBean", null, 0, -1, FacesConfigType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFacesConfigType_Name(), this.getNameType(), null, "name", null, 0, 1, FacesConfigType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFacesConfigType_NavigationRule(), this.getNavigationRuleType(), null, "navigationRule", null, 0, -1, FacesConfigType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFacesConfigType_ReferencedBean(), this.getReferencedBeanType(), null, "referencedBean", null, 0, -1, FacesConfigType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFacesConfigType_RenderKit(), this.getRenderKitType(), null, "renderKit", null, 0, -1, FacesConfigType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFacesConfigType_Lifecycle(), this.getLifecycleType(), null, "lifecycle", null, 0, -1, FacesConfigType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFacesConfigType_Validator(), this.getValidatorType(), null, "validator", null, 0, -1, FacesConfigType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFacesConfigType_Behavior(), this.getBehaviorType(), null, "behavior", null, 0, -1, FacesConfigType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFacesConfigType_FacesConfigExtension(), this.getFacesConfigExtensionType(), null, "facesConfigExtension", null, 0, -1, FacesConfigType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getFacesConfigType_Xmlns(), theXMLTypePackage.getString(), "xmlns", "http://java.sun.com/JSF/Configuration", 0, 1, FacesConfigType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getFacesConfigType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, FacesConfigType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getFacesConfigType_MetadataComplete(), theXMLTypePackage.getBoolean(), "metadataComplete", null, 0, 1, FacesConfigType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(facesConfigExtensionTypeEClass, FacesConfigExtensionType.class, "FacesConfigExtensionType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(facesContextFactoryTypeEClass, FacesContextFactoryType.class, "FacesContextFactoryType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getFacesContextFactoryType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, FacesContextFactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getFacesContextFactoryType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, FacesContextFactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(facetExtensionTypeEClass, FacetExtensionType.class, "FacetExtensionType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(facetNameTypeEClass, FacetNameType.class, "FacetNameType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getFacetNameType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, FacetNameType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getFacetNameType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, FacetNameType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(facetTypeEClass, FacetType.class, "FacetType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getFacetType_Description(), this.getDescriptionType(), null, "description", null, 0, -1, FacetType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFacetType_DisplayName(), this.getDisplayNameType(), null, "displayName", null, 0, -1, FacetType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFacetType_Icon(), this.getIconType(), null, "icon", null, 0, -1, FacetType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFacetType_FacetName(), this.getFacetNameType(), null, "facetName", null, 1, 1, FacetType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFacetType_FacetExtension(), this.getFacetExtensionType(), null, "facetExtension", null, 0, -1, FacetType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getFacetType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, FacetType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(factoryTypeEClass, FactoryType.class, "FactoryType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getFactoryType_ApplicationFactory(), this.getApplicationFactoryType(), null, "applicationFactory", null, 0, -1, FactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFactoryType_ExceptionHandlerFactory(), this.getExceptionHandlerFactoryType(), null, "exceptionHandlerFactory", null, 0, -1, FactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFactoryType_ExternalContextFactory(), this.getExternalContextFactoryType(), null, "externalContextFactory", null, 0, -1, FactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFactoryType_FacesContextFactory(), this.getFacesContextFactoryType(), null, "facesContextFactory", null, 0, -1, FactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFactoryType_PartialViewContextFactory(), this.getPartialViewContextFactoryType(), null, "partialViewContextFactory", null, 0, -1, FactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFactoryType_LifecycleFactory(), this.getLifecycleFactoryType(), null, "lifecycleFactory", null, 0, -1, FactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFactoryType_ViewDeclarationLanguageFactory(), this.getViewDeclarationLanguageFactoryType(), null, "viewDeclarationLanguageFactory", null, 0, -1, FactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFactoryType_TagHandlerDelegateFactory(), this.getTagHandlerDelegateFactoryType(), null, "tagHandlerDelegateFactory", null, 0, -1, FactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFactoryType_RenderKitFactory(), this.getRenderKitFactoryType(), null, "renderKitFactory", null, 0, -1, FactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFactoryType_VisitContextFactory(), this.getVisitContextFactoryType(), null, "visitContextFactory", null, 0, -1, FactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getFactoryType_FactoryExtension(), this.getFactoryExtensionType(), null, "factoryExtension", null, 0, -1, FactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getFactoryType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, FactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(factoryExtensionTypeEClass, FactoryExtensionType.class, "FactoryExtensionType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(fromActionTypeEClass, FromActionType.class, "FromActionType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getFromActionType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, FromActionType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getFromActionType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, FromActionType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(fromOutcomeTypeEClass, FromOutcomeType.class, "FromOutcomeType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getFromOutcomeType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, FromOutcomeType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getFromOutcomeType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, FromOutcomeType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(fromViewIdTypeEClass, FromViewIdType.class, "FromViewIdType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getFromViewIdType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, FromViewIdType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getFromViewIdType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, FromViewIdType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(iconTypeEClass, IconType.class, "IconType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getIconType_SmallIcon(), this.getSmallIconType(), null, "smallIcon", null, 0, 1, IconType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getIconType_LargeIcon(), this.getLargeIconType(), null, "largeIcon", null, 0, 1, IconType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getIconType_Lang(), theXMLTypePackage.getLanguage(), "lang", null, 0, 1, IconType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getIconType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, IconType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(ifTypeEClass, IfType.class, "IfType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getIfType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, IfType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getIfType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, IfType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(keyClassTypeEClass, KeyClassType.class, "KeyClassType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getKeyClassType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, KeyClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getKeyClassType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, KeyClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(keyTypeEClass, KeyType.class, "KeyType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getKeyType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, KeyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getKeyType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, KeyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(largeIconTypeEClass, LargeIconType.class, "LargeIconType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getLargeIconType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, LargeIconType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getLargeIconType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, LargeIconType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(lifecycleFactoryTypeEClass, LifecycleFactoryType.class, "LifecycleFactoryType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getLifecycleFactoryType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, LifecycleFactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getLifecycleFactoryType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, LifecycleFactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(lifecycleTypeEClass, LifecycleType.class, "LifecycleType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getLifecycleType_PhaseListener(), this.getPhaseListenerType(), null, "phaseListener", null, 0, -1, LifecycleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getLifecycleType_LifecycleExtension(), this.getLifecycleExtensionType(), null, "lifecycleExtension", null, 0, -1, LifecycleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getLifecycleType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, LifecycleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(lifecycleExtensionTypeEClass, LifecycleExtensionType.class, "LifecycleExtensionType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(listEntriesTypeEClass, ListEntriesType.class, "ListEntriesType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getListEntriesType_ValueClass(), this.getValueClassType(), null, "valueClass", null, 0, 1, ListEntriesType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getListEntriesType_NullValue(), this.getNullValueType(), null, "nullValue", null, 0, -1, ListEntriesType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getListEntriesType_Value(), this.getValueType(), null, "value", null, 0, -1, ListEntriesType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getListEntriesType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ListEntriesType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(localeConfigTypeEClass, LocaleConfigType.class, "LocaleConfigType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getLocaleConfigType_DefaultLocale(), this.getDefaultLocaleType(), null, "defaultLocale", null, 0, 1, LocaleConfigType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getLocaleConfigType_SupportedLocale(), this.getSupportedLocaleType(), null, "supportedLocale", null, 0, -1, LocaleConfigType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getLocaleConfigType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, LocaleConfigType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(managedBeanClassTypeEClass, ManagedBeanClassType.class, "ManagedBeanClassType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getManagedBeanClassType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ManagedBeanClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getManagedBeanClassType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ManagedBeanClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(managedBeanNameTypeEClass, ManagedBeanNameType.class, "ManagedBeanNameType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getManagedBeanNameType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ManagedBeanNameType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getManagedBeanNameType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ManagedBeanNameType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(managedBeanScopeTypeEClass, ManagedBeanScopeType.class, "ManagedBeanScopeType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getManagedBeanScopeType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ManagedBeanScopeType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getManagedBeanScopeType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ManagedBeanScopeType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(managedBeanTypeEClass, ManagedBeanType.class, "ManagedBeanType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getManagedBeanType_Description(), this.getDescriptionType(), null, "description", null, 0, -1, ManagedBeanType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getManagedBeanType_DisplayName(), this.getDisplayNameType(), null, "displayName", null, 0, -1, ManagedBeanType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getManagedBeanType_Icon(), this.getIconType(), null, "icon", null, 0, -1, ManagedBeanType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getManagedBeanType_ManagedBeanName(), this.getManagedBeanNameType(), null, "managedBeanName", null, 1, 1, ManagedBeanType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getManagedBeanType_ManagedBeanClass(), this.getManagedBeanClassType(), null, "managedBeanClass", null, 1, 1, ManagedBeanType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getManagedBeanType_ManagedBeanScope(), this.getManagedBeanScopeType(), null, "managedBeanScope", null, 1, 1, ManagedBeanType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getManagedBeanType_ManagedProperty(), this.getManagedPropertyType(), null, "managedProperty", null, 0, -1, ManagedBeanType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getManagedBeanType_MapEntries(), this.getMapEntriesType(), null, "mapEntries", null, 0, 1, ManagedBeanType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getManagedBeanType_ListEntries(), this.getListEntriesType(), null, "listEntries", null, 0, 1, ManagedBeanType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getManagedBeanType_ManagedBeanExtension(), this.getManagedBeanExtensionType(), null, "managedBeanExtension", null, 0, -1, ManagedBeanType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getManagedBeanType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ManagedBeanType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getManagedBeanType_Eager(), theXMLTypePackage.getBoolean(), "eager", null, 0, 1, ManagedBeanType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(managedBeanExtensionTypeEClass, ManagedBeanExtensionType.class, "ManagedBeanExtensionType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(managedPropertyTypeEClass, ManagedPropertyType.class, "ManagedPropertyType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getManagedPropertyType_Description(), this.getDescriptionType(), null, "description", null, 0, -1, ManagedPropertyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getManagedPropertyType_DisplayName(), this.getDisplayNameType(), null, "displayName", null, 0, -1, ManagedPropertyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getManagedPropertyType_Icon(), this.getIconType(), null, "icon", null, 0, -1, ManagedPropertyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getManagedPropertyType_PropertyName(), this.getPropertyNameType(), null, "propertyName", null, 1, 1, ManagedPropertyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getManagedPropertyType_PropertyClass(), this.getPropertyClassType(), null, "propertyClass", null, 0, 1, ManagedPropertyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getManagedPropertyType_MapEntries(), this.getMapEntriesType(), null, "mapEntries", null, 0, 1, ManagedPropertyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getManagedPropertyType_NullValue(), this.getNullValueType(), null, "nullValue", null, 0, 1, ManagedPropertyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getManagedPropertyType_Value(), this.getValueType(), null, "value", null, 0, 1, ManagedPropertyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getManagedPropertyType_ListEntries(), this.getListEntriesType(), null, "listEntries", null, 0, 1, ManagedPropertyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getManagedPropertyType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ManagedPropertyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(mapEntriesTypeEClass, MapEntriesType.class, "MapEntriesType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getMapEntriesType_KeyClass(), this.getKeyClassType(), null, "keyClass", null, 0, 1, MapEntriesType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getMapEntriesType_ValueClass(), this.getValueClassType(), null, "valueClass", null, 0, 1, MapEntriesType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getMapEntriesType_MapEntry(), this.getMapEntryType(), null, "mapEntry", null, 0, -1, MapEntriesType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getMapEntriesType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, MapEntriesType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(mapEntryTypeEClass, MapEntryType.class, "MapEntryType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getMapEntryType_Key(), this.getKeyType(), null, "key", null, 1, 1, MapEntryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getMapEntryType_NullValue(), this.getNullValueType(), null, "nullValue", null, 0, 1, MapEntryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getMapEntryType_Value(), this.getValueType(), null, "value", null, 0, 1, MapEntryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getMapEntryType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, MapEntryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(messageBundleTypeEClass, MessageBundleType.class, "MessageBundleType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getMessageBundleType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, MessageBundleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getMessageBundleType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, MessageBundleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(nameTypeEClass, NameType.class, "NameType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getNameType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, NameType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getNameType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, NameType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(navigationCaseTypeEClass, NavigationCaseType.class, "NavigationCaseType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getNavigationCaseType_Description(), this.getDescriptionType(), null, "description", null, 0, -1, NavigationCaseType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getNavigationCaseType_DisplayName(), this.getDisplayNameType(), null, "displayName", null, 0, -1, NavigationCaseType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getNavigationCaseType_Icon(), this.getIconType(), null, "icon", null, 0, -1, NavigationCaseType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getNavigationCaseType_FromAction(), this.getFromActionType(), null, "fromAction", null, 0, 1, NavigationCaseType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getNavigationCaseType_FromOutcome(), this.getFromOutcomeType(), null, "fromOutcome", null, 0, 1, NavigationCaseType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getNavigationCaseType_If(), this.getIfType(), null, "if", null, 0, 1, NavigationCaseType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getNavigationCaseType_ToViewId(), this.getToViewIdType(), null, "toViewId", null, 1, 1, NavigationCaseType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getNavigationCaseType_Redirect(), this.getRedirectType(), null, "redirect", null, 0, 1, NavigationCaseType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getNavigationCaseType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, NavigationCaseType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(navigationHandlerTypeEClass, NavigationHandlerType.class, "NavigationHandlerType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getNavigationHandlerType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, NavigationHandlerType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getNavigationHandlerType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, NavigationHandlerType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(navigationRuleTypeEClass, NavigationRuleType.class, "NavigationRuleType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getNavigationRuleType_Description(), this.getDescriptionType(), null, "description", null, 0, -1, NavigationRuleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getNavigationRuleType_DisplayName(), this.getDisplayNameType(), null, "displayName", null, 0, -1, NavigationRuleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getNavigationRuleType_Icon(), this.getIconType(), null, "icon", null, 0, -1, NavigationRuleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getNavigationRuleType_FromViewId(), this.getFromViewIdType(), null, "fromViewId", null, 0, 1, NavigationRuleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getNavigationRuleType_NavigationCase(), this.getNavigationCaseType(), null, "navigationCase", null, 0, -1, NavigationRuleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getNavigationRuleType_NavigationRuleExtension(), this.getNavigationRuleExtensionType(), null, "navigationRuleExtension", null, 0, -1, NavigationRuleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getNavigationRuleType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, NavigationRuleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(navigationRuleExtensionTypeEClass, NavigationRuleExtensionType.class, "NavigationRuleExtensionType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(nullValueTypeEClass, NullValueType.class, "NullValueType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getNullValueType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, NullValueType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(orderingTypeEClass, OrderingType.class, "OrderingType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getOrderingType_Before(), this.getOrderingOrderingType(), null, "before", null, 0, 1, OrderingType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getOrderingType_After(), this.getOrderingOrderingType(), null, "after", null, 0, 1, OrderingType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(orderingOrderingTypeEClass, OrderingOrderingType.class, "OrderingOrderingType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getOrderingOrderingType_Name(), this.getNameType(), null, "name", null, 0, -1, OrderingOrderingType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getOrderingOrderingType_Others(), this.getOrderingOthersType(), null, "others", null, 0, 1, OrderingOrderingType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(orderingOthersTypeEClass, OrderingOthersType.class, "OrderingOthersType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getOrderingOthersType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, OrderingOthersType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(partialViewContextFactoryTypeEClass, PartialViewContextFactoryType.class, "PartialViewContextFactoryType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getPartialViewContextFactoryType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, PartialViewContextFactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getPartialViewContextFactoryType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, PartialViewContextFactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(phaseListenerTypeEClass, PhaseListenerType.class, "PhaseListenerType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getPhaseListenerType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, PhaseListenerType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getPhaseListenerType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, PhaseListenerType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(propertyClassTypeEClass, PropertyClassType.class, "PropertyClassType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getPropertyClassType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, PropertyClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getPropertyClassType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, PropertyClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(propertyExtensionTypeEClass, PropertyExtensionType.class, "PropertyExtensionType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(propertyNameTypeEClass, PropertyNameType.class, "PropertyNameType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getPropertyNameType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, PropertyNameType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getPropertyNameType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, PropertyNameType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(propertyResolverTypeEClass, PropertyResolverType.class, "PropertyResolverType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getPropertyResolverType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, PropertyResolverType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getPropertyResolverType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, PropertyResolverType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(propertyTypeEClass, PropertyType.class, "PropertyType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getPropertyType_Description(), this.getDescriptionType(), null, "description", null, 0, -1, PropertyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPropertyType_DisplayName(), this.getDisplayNameType(), null, "displayName", null, 0, -1, PropertyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPropertyType_Icon(), this.getIconType(), null, "icon", null, 0, -1, PropertyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPropertyType_PropertyName(), this.getPropertyNameType(), null, "propertyName", null, 1, 1, PropertyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPropertyType_PropertyClass(), this.getPropertyClassType(), null, "propertyClass", null, 1, 1, PropertyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPropertyType_DefaultValue(), this.getDefaultValueType(), null, "defaultValue", null, 0, 1, PropertyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPropertyType_SuggestedValue(), this.getSuggestedValueType(), null, "suggestedValue", null, 0, 1, PropertyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPropertyType_PropertyExtension(), this.getPropertyExtensionType(), null, "propertyExtension", null, 0, -1, PropertyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getPropertyType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, PropertyType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(redirectTypeEClass, RedirectType.class, "RedirectType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getRedirectType_ViewParam(), this.getRedirectViewParamType(), null, "viewParam", null, 0, -1, RedirectType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getRedirectType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, RedirectType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getRedirectType_IncludeViewParams(), theXMLTypePackage.getBoolean(), "includeViewParams", null, 0, 1, RedirectType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(redirectViewParamTypeEClass, RedirectViewParamType.class, "RedirectViewParamType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getRedirectViewParamType_Name(), this.getNameType(), null, "name", null, 1, 1, RedirectViewParamType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getRedirectViewParamType_Value(), this.getValueType(), null, "value", null, 1, 1, RedirectViewParamType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getRedirectViewParamType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, RedirectViewParamType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(referencedBeanClassTypeEClass, ReferencedBeanClassType.class, "ReferencedBeanClassType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getReferencedBeanClassType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ReferencedBeanClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getReferencedBeanClassType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ReferencedBeanClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(referencedBeanNameTypeEClass, ReferencedBeanNameType.class, "ReferencedBeanNameType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getReferencedBeanNameType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ReferencedBeanNameType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getReferencedBeanNameType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ReferencedBeanNameType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(referencedBeanTypeEClass, ReferencedBeanType.class, "ReferencedBeanType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getReferencedBeanType_Description(), this.getDescriptionType(), null, "description", null, 0, -1, ReferencedBeanType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getReferencedBeanType_DisplayName(), this.getDisplayNameType(), null, "displayName", null, 0, -1, ReferencedBeanType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getReferencedBeanType_Icon(), this.getIconType(), null, "icon", null, 0, -1, ReferencedBeanType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getReferencedBeanType_ReferencedBeanName(), this.getReferencedBeanNameType(), null, "referencedBeanName", null, 1, 1, ReferencedBeanType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getReferencedBeanType_ReferencedBeanClass(), this.getReferencedBeanClassType(), null, "referencedBeanClass", null, 1, 1, ReferencedBeanType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getReferencedBeanType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ReferencedBeanType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(rendererClassTypeEClass, RendererClassType.class, "RendererClassType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getRendererClassType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, RendererClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getRendererClassType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, RendererClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(rendererExtensionTypeEClass, RendererExtensionType.class, "RendererExtensionType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(rendererTypeEClass, RendererType.class, "RendererType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getRendererType_Description(), this.getDescriptionType(), null, "description", null, 0, -1, RendererType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getRendererType_DisplayName(), this.getDisplayNameType(), null, "displayName", null, 0, -1, RendererType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getRendererType_Icon(), this.getIconType(), null, "icon", null, 0, -1, RendererType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getRendererType_ComponentFamily(), this.getComponentFamilyType(), null, "componentFamily", null, 1, 1, RendererType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getRendererType_RendererType(), this.getRendererTypeType(), null, "rendererType", null, 1, 1, RendererType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getRendererType_RendererClass(), this.getRendererClassType(), null, "rendererClass", null, 1, 1, RendererType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getRendererType_Facet(), this.getFacetType(), null, "facet", null, 0, -1, RendererType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getRendererType_Attribute(), this.getAttributeType(), null, "attribute", null, 0, -1, RendererType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getRendererType_RendererExtension(), this.getRendererExtensionType(), null, "rendererExtension", null, 0, -1, RendererType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getRendererType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, RendererType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(rendererTypeTypeEClass, RendererTypeType.class, "RendererTypeType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getRendererTypeType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, RendererTypeType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getRendererTypeType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, RendererTypeType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(renderKitClassTypeEClass, RenderKitClassType.class, "RenderKitClassType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getRenderKitClassType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, RenderKitClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getRenderKitClassType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, RenderKitClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(renderKitFactoryTypeEClass, RenderKitFactoryType.class, "RenderKitFactoryType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getRenderKitFactoryType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, RenderKitFactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getRenderKitFactoryType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, RenderKitFactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(renderKitIdTypeEClass, RenderKitIdType.class, "RenderKitIdType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getRenderKitIdType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, RenderKitIdType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getRenderKitIdType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, RenderKitIdType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(renderKitTypeEClass, RenderKitType.class, "RenderKitType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getRenderKitType_Description(), this.getDescriptionType(), null, "description", null, 0, -1, RenderKitType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getRenderKitType_DisplayName(), this.getDisplayNameType(), null, "displayName", null, 0, -1, RenderKitType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getRenderKitType_Icon(), this.getIconType(), null, "icon", null, 0, -1, RenderKitType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getRenderKitType_RenderKitId(), this.getRenderKitIdType(), null, "renderKitId", null, 0, 1, RenderKitType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getRenderKitType_RenderKitClass(), this.getRenderKitClassType(), null, "renderKitClass", null, 0, 1, RenderKitType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getRenderKitType_Renderer(), this.getRendererType(), null, "renderer", null, 0, -1, RenderKitType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getRenderKitType_ClientBehaviorRenderer(), this.getClientBehaviorRendererType(), null, "clientBehaviorRenderer", null, 0, -1, RenderKitType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getRenderKitType_RenderKitExtension(), this.getRenderKitExtensionType(), null, "renderKitExtension", null, 0, -1, RenderKitType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getRenderKitType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, RenderKitType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(renderKitExtensionTypeEClass, RenderKitExtensionType.class, "RenderKitExtensionType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(resourceHandlerTypeEClass, ResourceHandlerType.class, "ResourceHandlerType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getResourceHandlerType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ResourceHandlerType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getResourceHandlerType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ResourceHandlerType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(smallIconTypeEClass, SmallIconType.class, "SmallIconType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getSmallIconType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, SmallIconType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getSmallIconType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, SmallIconType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(sourceClassTypeEClass, SourceClassType.class, "SourceClassType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getSourceClassType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, SourceClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getSourceClassType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, SourceClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(stateManagerTypeEClass, StateManagerType.class, "StateManagerType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getStateManagerType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, StateManagerType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getStateManagerType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, StateManagerType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(suggestedValueTypeEClass, SuggestedValueType.class, "SuggestedValueType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getSuggestedValueType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, SuggestedValueType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getSuggestedValueType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, SuggestedValueType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(supportedLocaleTypeEClass, SupportedLocaleType.class, "SupportedLocaleType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getSupportedLocaleType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, SupportedLocaleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getSupportedLocaleType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, SupportedLocaleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(systemEventClassTypeEClass, SystemEventClassType.class, "SystemEventClassType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getSystemEventClassType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, SystemEventClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getSystemEventClassType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, SystemEventClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(systemEventListenerClassTypeEClass, SystemEventListenerClassType.class, "SystemEventListenerClassType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getSystemEventListenerClassType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, SystemEventListenerClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getSystemEventListenerClassType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, SystemEventListenerClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(systemEventListenerTypeEClass, SystemEventListenerType.class, "SystemEventListenerType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getSystemEventListenerType_SystemEventListenerClass(), this.getSystemEventListenerClassType(), null, "systemEventListenerClass", null, 1, 1, SystemEventListenerType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getSystemEventListenerType_SystemEventClass(), this.getSystemEventClassType(), null, "systemEventClass", null, 1, 1, SystemEventListenerType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getSystemEventListenerType_SourceClass(), this.getSourceClassType(), null, "sourceClass", null, 0, 1, SystemEventListenerType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getSystemEventListenerType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, SystemEventListenerType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(tagHandlerDelegateFactoryTypeEClass, TagHandlerDelegateFactoryType.class, "TagHandlerDelegateFactoryType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getTagHandlerDelegateFactoryType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, TagHandlerDelegateFactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getTagHandlerDelegateFactoryType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, TagHandlerDelegateFactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(toViewIdTypeEClass, ToViewIdType.class, "ToViewIdType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getToViewIdType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ToViewIdType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getToViewIdType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ToViewIdType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(validatorClassTypeEClass, ValidatorClassType.class, "ValidatorClassType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getValidatorClassType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ValidatorClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getValidatorClassType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ValidatorClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(validatorIdTypeEClass, ValidatorIdType.class, "ValidatorIdType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getValidatorIdType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ValidatorIdType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getValidatorIdType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ValidatorIdType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(validatorTypeEClass, ValidatorType.class, "ValidatorType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getValidatorType_Description(), this.getDescriptionType(), null, "description", null, 0, -1, ValidatorType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getValidatorType_DisplayName(), this.getDisplayNameType(), null, "displayName", null, 0, -1, ValidatorType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getValidatorType_Icon(), this.getIconType(), null, "icon", null, 0, -1, ValidatorType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getValidatorType_ValidatorId(), this.getValidatorIdType(), null, "validatorId", null, 1, 1, ValidatorType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getValidatorType_ValidatorClass(), this.getValidatorClassType(), null, "validatorClass", null, 1, 1, ValidatorType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getValidatorType_Attribute(), this.getAttributeType(), null, "attribute", null, 0, -1, ValidatorType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getValidatorType_Property(), this.getPropertyType(), null, "property", null, 0, -1, ValidatorType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getValidatorType_ValidatorExtension(), this.getValidatorExtensionType(), null, "validatorExtension", null, 0, -1, ValidatorType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getValidatorType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ValidatorType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(validatorExtensionTypeEClass, ValidatorExtensionType.class, "ValidatorExtensionType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		initEClass(valueClassTypeEClass, ValueClassType.class, "ValueClassType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getValueClassType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ValueClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getValueClassType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ValueClassType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(valueTypeEClass, ValueType.class, "ValueType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getValueType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ValueType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getValueType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ValueType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(variableResolverTypeEClass, VariableResolverType.class, "VariableResolverType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getVariableResolverType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, VariableResolverType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getVariableResolverType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, VariableResolverType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(viewHandlerTypeEClass, ViewHandlerType.class, "ViewHandlerType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getViewHandlerType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ViewHandlerType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getViewHandlerType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ViewHandlerType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(resourceBundleTypeEClass, ResourceBundleType.class, "ResourceBundleType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getResourceBundleType_Description(), this.getDescriptionType(), null, "description", null, 0, -1, ResourceBundleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getResourceBundleType_DisplayName(), this.getDisplayNameType(), null, "displayName", null, 0, -1, ResourceBundleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getResourceBundleType_Icon(), this.getIconType(), null, "icon", null, 0, -1, ResourceBundleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getResourceBundleType_BaseName(), this.getBaseNameType(), null, "baseName", null, 0, 1, ResourceBundleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getResourceBundleType_Var(), this.getVarType(), null, "var", null, 0, 1, ResourceBundleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getResourceBundleType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ResourceBundleType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(baseNameTypeEClass, BaseNameType.class, "BaseNameType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getBaseNameType_TextContent(), ecorePackage.getEString(), "textContent", null, 0, 1, BaseNameType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getBaseNameType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, BaseNameType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(varTypeEClass, VarType.class, "VarType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getVarType_TextContent(), ecorePackage.getEString(), "textContent", null, 0, 1, VarType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getVarType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, VarType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(viewDeclarationLanguageFactoryTypeEClass, ViewDeclarationLanguageFactoryType.class, "ViewDeclarationLanguageFactoryType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getViewDeclarationLanguageFactoryType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, ViewDeclarationLanguageFactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getViewDeclarationLanguageFactoryType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, ViewDeclarationLanguageFactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(visitContextFactoryTypeEClass, VisitContextFactoryType.class, "VisitContextFactoryType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getVisitContextFactoryType_TextContent(), theXMLTypePackage.getString(), "textContent", null, 0, 1, VisitContextFactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getVisitContextFactoryType_Id(), theXMLTypePackage.getID(), "id", null, 0, 1, VisitContextFactoryType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		// Create resource
-		createResource(eNS_URI);
-
-		// Create annotations
-		// http:///org/eclipse/emf/ecore/util/ExtendedMetaData
-		createExtendedMetaDataAnnotations();
-	}
-
-    /**
-	 * Initializes the annotations for <b>http:///org/eclipse/emf/ecore/util/ExtendedMetaData</b>.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void createExtendedMetaDataAnnotations() {
-		String source = "http:///org/eclipse/emf/ecore/util/ExtendedMetaData";			
-		addAnnotation
-		  (this, 
-		   source, 
-		   new String[] {
-			 "qualified", "false"
-		   });		
-		addAnnotation
-		  (absoluteOrderingTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "absolute-ordering_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getAbsoluteOrderingType_Name(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getAbsoluteOrderingType_Others(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "others",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (actionListenerTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "action-listener_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getActionListenerType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getActionListenerType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (applicationFactoryTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "application-factory_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getApplicationFactoryType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getApplicationFactoryType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (applicationTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "application_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getApplicationType_ActionListener(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "action-listener",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getApplicationType_DefaultRenderKitId(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "default-render-kit-id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getApplicationType_MessageBundle(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "message-bundle",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getApplicationType_NavigationHandler(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "navigation-handler",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getApplicationType_ViewHandler(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "view-handler",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getApplicationType_StateManager(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "state-manager",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getApplicationType_ELResolver(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "el-resolver",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getApplicationType_PropertyResolver(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "property-resolver",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getApplicationType_VariableResolver(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "variable-resolver",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getApplicationType_ResourceHandler(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "resource-handler",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getApplicationType_SystemEventListener(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "system-event-listener",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getApplicationType_LocaleConfig(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "locale-config",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getApplicationType_ResourceBundle(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "resource-bundle",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getApplicationType_ApplicationExtension(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "application-extension",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getApplicationType_DefaultValidators(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "default-validators",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getApplicationType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (applicationExtensionTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "application-extension_._type"
-		   });		
-		addAnnotation
-		  (attributeClassTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "attribute-class_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getAttributeClassType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getAttributeClassType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (attributeExtensionTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "attribute-extension_._type"
-		   });		
-		addAnnotation
-		  (attributeNameTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "attribute-name_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getAttributeNameType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getAttributeNameType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (attributeTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "attribute_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getAttributeType_Description(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "description",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getAttributeType_DisplayName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "display-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getAttributeType_Icon(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "icon",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getAttributeType_AttributeName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "attribute-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getAttributeType_AttributeClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "attribute-class",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getAttributeType_DefaultValue(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "default-value",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getAttributeType_SuggestedValue(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "suggested-value",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getAttributeType_AttributeExtension(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "attribute-extension",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getAttributeType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (behaviorClassTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "behavior-class_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getBehaviorClassType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getBehaviorClassType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (behaviorIdTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "behavior-id_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getBehaviorIdType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getBehaviorIdType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (behaviorTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "behavior_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getBehaviorType_Description(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "description",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getBehaviorType_DisplayName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "display-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getBehaviorType_Icon(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "icon",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getBehaviorType_BehaviorId(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "behavior-id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getBehaviorType_BehaviorClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "behavior-class",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getBehaviorType_Attribute(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "attribute",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getBehaviorType_Property(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "property",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getBehaviorType_BehaviorExtension(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "behavior-extension",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (behaviorExtensionTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "behavior-extension_._type"
-		   });		
-		addAnnotation
-		  (clientBehaviorRendererClassTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "client-behavior-renderer-class_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getClientBehaviorRendererClassType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getClientBehaviorRendererClassType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (clientBehaviorRendererTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "client-behavior-renderer_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getClientBehaviorRendererType_ClientBehaviorRendererType(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "client-behavior-renderer-type",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getClientBehaviorRendererType_ClientBehaviorRendererClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "client-behavior-renderer-class",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (clientBehaviorRendererTypeTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "client-behavior-renderer-type_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getClientBehaviorRendererTypeType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getClientBehaviorRendererTypeType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (componentClassTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "component-class_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getComponentClassType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getComponentClassType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (componentExtensionTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "component-extension_._type"
-		   });		
-		addAnnotation
-		  (componentFamilyTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "component-family_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getComponentFamilyType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getComponentFamilyType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (componentTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "component_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getComponentType_Description(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "description",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getComponentType_DisplayName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "display-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getComponentType_Icon(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "icon",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getComponentType_ComponentType(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "component-type",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getComponentType_ComponentClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "component-class",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getComponentType_Facet(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "facet",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getComponentType_Attribute(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "attribute",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getComponentType_Property(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "property",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getComponentType_ComponentExtension(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "component-extension",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getComponentType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (componentTypeTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "component-type_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getComponentTypeType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getComponentTypeType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (converterClassTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "converter-class_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getConverterClassType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getConverterClassType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (converterForClassTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "converter-for-class_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getConverterForClassType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getConverterForClassType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (converterIdTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "converter-id_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getConverterIdType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getConverterIdType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (converterTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "converter_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getConverterType_Description(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "description",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getConverterType_DisplayName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "display-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getConverterType_Icon(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "icon",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getConverterType_ConverterId(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "converter-id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getConverterType_ConverterForClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "converter-for-class",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getConverterType_ConverterClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "converter-class",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getConverterType_Attribute(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "attribute",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getConverterType_Property(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "property",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getConverterType_ConverterExtension(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "converter-extension",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getConverterType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (converterExtensionTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "converter-extension_._type"
-		   });		
-		addAnnotation
-		  (defaultLocaleTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "default-locale_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getDefaultLocaleType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getDefaultLocaleType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (defaultRenderKitIdTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "default-render-kit-id_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getDefaultRenderKitIdType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getDefaultRenderKitIdType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (defaultValidatorsTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "default-validators_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getDefaultValidatorsType_ValidatorId(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "validator-id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getDefaultValidatorsType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (defaultValueTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "default-value_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getDefaultValueType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getDefaultValueType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (descriptionTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "description_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getDescriptionType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getDescriptionType_Lang(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "lang",
-			 "namespace", "http://www.w3.org/XML/1998/namespace"
-		   });		
-		addAnnotation
-		  (getDescriptionType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (displayNameTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "display-name_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getDisplayNameType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getDisplayNameType_Lang(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "lang",
-			 "namespace", "http://www.w3.org/XML/1998/namespace"
-		   });		
-		addAnnotation
-		  (getDisplayNameType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (documentRootEClass, 
-		   source, 
-		   new String[] {
-			 "name", "",
-			 "kind", "mixed"
-		   });		
-		addAnnotation
-		  (getDocumentRoot_Mixed(), 
-		   source, 
-		   new String[] {
-			 "kind", "elementWildcard",
-			 "name", ":mixed"
-		   });		
-		addAnnotation
-		  (getDocumentRoot_XMLNSPrefixMap(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "xmlns:prefix"
-		   });		
-		addAnnotation
-		  (getDocumentRoot_XSISchemaLocation(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "xsi:schemaLocation"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_AbsoluteOrdering(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "absolute-ordering",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ActionListener(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "action-listener",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_Application(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "application",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ApplicationFactory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "application-factory",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_Attribute(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "attribute",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_AttributeClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "attribute-class",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_AttributeExtension(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "attribute-extension",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_AttributeName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "attribute-name",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_Behavior(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "behavior",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_BehaviorClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "behavior-class",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_BehaviorId(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "behavior-id",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_BehaviorExtension(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "behavior-extension",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_Component(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "component",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ComponentClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "component-class",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ComponentExtension(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "component-extension",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ComponentFamily(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "component-family",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ComponentType(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "component-type",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_Converter(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "converter",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ConverterClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "converter-class",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ConverterForClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "converter-for-class",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ConverterId(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "converter-id",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_DefaultLocale(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "default-locale",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_DefaultRenderKitId(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "default-render-kit-id",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_DefaultValidators(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "default-validators",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_DefaultValue(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "default-value",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_Description(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "description",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_DisplayName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "display-name",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ExceptionHandlerFactory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "exception-handler-factory",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ExternalContextFactory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "external-context-factory",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_FacesConfig(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "faces-config",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_FacesContextFactory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "faces-context-factory",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_Facet(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "facet",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_FacetExtension(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "facet-extension",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_FacetName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "facet-name",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_Factory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "factory",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_FromAction(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "from-action",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_FromOutcome(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "from-outcome",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_FromViewId(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "from-view-id",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_Icon(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "icon",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_If(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "if",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_Key(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "key",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_KeyClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "key-class",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_LargeIcon(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "large-icon",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_Lifecycle(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "lifecycle",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_LifecycleFactory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "lifecycle-factory",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ListEntries(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "list-entries",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_LocaleConfig(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "locale-config",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ManagedBean(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "managed-bean",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ManagedBeanClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "managed-bean-class",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ManagedBeanName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "managed-bean-name",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ManagedBeanScope(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "managed-bean-scope",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ManagedProperty(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "managed-property",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_MapEntries(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "map-entries",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_MapEntry(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "map-entry",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_MessageBundle(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "message-bundle",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_Name(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "name",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_NavigationCase(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "navigation-case",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_NavigationHandler(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "navigation-handler",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_NavigationRule(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "navigation-rule",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_NullValue(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "null-value",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_Ordering(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "ordering",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_OrderingOrdering(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "ordering-ordering",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_Others(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "others",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_PartialViewContextFactory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "partial-view-context-factory",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_PhaseListener(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "phase-listener",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_Property(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "property",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_PropertyClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "property-class",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_PropertyExtension(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "property-extension",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_PropertyName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "property-name",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_PropertyResolver(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "property-resolver",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_Redirect(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "redirect",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_RedirectViewParam(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "view-param",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ReferencedBean(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "referenced-bean",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ReferencedBeanClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "referenced-bean-class",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ReferencedBeanName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "referenced-bean-name",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_Renderer(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "renderer",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_RendererClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "renderer-class",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_RendererExtension(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "renderer-extension",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_RendererType(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "renderer-type",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_RenderKit(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "render-kit",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_RenderKitClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "render-kit-class",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_RenderKitFactory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "render-kit-factory",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_RenderKitId(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "render-kit-id",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ResourceHandler(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "resource-handler",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_SmallIcon(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "small-icon",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_SourceClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "source-class",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_StateManager(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "state-manager",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_SuggestedValue(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "suggested-value",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_SupportedLocale(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "supported-locale",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_SystemEventClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "system-event-class",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_SystemEventListener(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "system-event-listener",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_SystemEventListenerClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "system-event-listener-class",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_TagHandlerDelegateFactory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "tag-handler-delegate-factory",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ToViewId(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "to-view-id",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_Validator(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "validator",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ValidatorClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "validator-class",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ValidatorId(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "validator-id",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_Value(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "value",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ValueClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "value-class",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_VariableResolver(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "variable-resolver",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ViewDeclarationLanguageFactory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "view-declaration-language-factory",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_ViewHandler(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "view-handler",
-			 "namespace", "##targetNamespace"
-		   });			
-		addAnnotation
-		  (getDocumentRoot_VisitContextFactory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "visit-context-factory",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (elResolverTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "el-resolver_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getELResolverType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getELResolverType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (exceptionHandlerFactoryTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "exception-handler-factory_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getExceptionHandlerFactoryType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getExceptionHandlerFactoryType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getExtensionType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getExtensionType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (externalContextFactoryTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "external-context-factory_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getExternalContextFactoryType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getExternalContextFactoryType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (facesConfigTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "faces-config_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getFacesConfigType_Application(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "application",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacesConfigType_Ordering(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "ordering",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacesConfigType_AbsoluteOrdering(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "absolute-ordering",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacesConfigType_Factory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "factory",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacesConfigType_Component(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "component",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacesConfigType_Converter(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "converter",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacesConfigType_ManagedBean(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "managed-bean",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacesConfigType_Name(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacesConfigType_NavigationRule(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "navigation-rule",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacesConfigType_ReferencedBean(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "referenced-bean",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacesConfigType_RenderKit(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "render-kit",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacesConfigType_Lifecycle(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "lifecycle",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacesConfigType_Validator(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "validator",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacesConfigType_Behavior(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "behavior",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacesConfigType_FacesConfigExtension(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "faces-config-extension",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacesConfigType_Xmlns(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "xmlns",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacesConfigType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacesConfigType_MetadataComplete(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "metadata-complete",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (facesConfigExtensionTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "faces-config-extension_._type"
-		   });		
-		addAnnotation
-		  (facesContextFactoryTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "faces-context-factory_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getFacesContextFactoryType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getFacesContextFactoryType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (facetExtensionTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "facet-extension_._type"
-		   });		
-		addAnnotation
-		  (facetNameTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "facet-name_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getFacetNameType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getFacetNameType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (facetTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "facet_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getFacetType_Description(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "description",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacetType_DisplayName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "display-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacetType_Icon(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "icon",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacetType_FacetName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "facet-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacetType_FacetExtension(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "facet-extension",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFacetType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (factoryTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "factory_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getFactoryType_ApplicationFactory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "application-factory",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFactoryType_ExceptionHandlerFactory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "exception-handler-factory",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFactoryType_ExternalContextFactory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "external-context-factory",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFactoryType_FacesContextFactory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "faces-context-factory",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFactoryType_PartialViewContextFactory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "partial-view-context-factory",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFactoryType_LifecycleFactory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "lifecycle-factory",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFactoryType_ViewDeclarationLanguageFactory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "view-declaration-language-factory",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFactoryType_TagHandlerDelegateFactory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "tag-handler-delegate-factory",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFactoryType_RenderKitFactory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "render-kit-factory",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFactoryType_VisitContextFactory(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "visit-context-factory",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFactoryType_FactoryExtension(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "factory-type",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getFactoryType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (factoryExtensionTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "factory-extension_._type"
-		   });		
-		addAnnotation
-		  (fromActionTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "from-action_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getFromActionType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getFromActionType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (fromOutcomeTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "from-outcome_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getFromOutcomeType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getFromOutcomeType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (fromViewIdTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "from-view-id_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getFromViewIdType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getFromViewIdType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (iconTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "icon_._type",
-			 "kind", "empty"
-		   });		
-		addAnnotation
-		  (getIconType_SmallIcon(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "small-icon",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getIconType_LargeIcon(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "large-icon",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getIconType_Lang(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "lang",
-			 "namespace", "http://www.w3.org/XML/1998/namespace"
-		   });		
-		addAnnotation
-		  (getIconType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (ifTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "if_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getIfType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getIfType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (keyClassTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "key-class_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getKeyClassType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getKeyClassType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (keyTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "key_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getKeyType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getKeyType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (largeIconTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "large-icon_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getLargeIconType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getLargeIconType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (lifecycleFactoryTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "lifecycle-factory_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getLifecycleFactoryType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getLifecycleFactoryType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (lifecycleTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "lifecycle_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getLifecycleType_PhaseListener(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "phase-listener",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getLifecycleType_LifecycleExtension(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "lifecycle-extension",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getLifecycleType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (lifecycleExtensionTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "lifecycle-extension_._type"
-		   });		
-		addAnnotation
-		  (listEntriesTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "list-entries_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getListEntriesType_ValueClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "value-class",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getListEntriesType_NullValue(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "null-value",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getListEntriesType_Value(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "value",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getListEntriesType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (localeConfigTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "locale-config_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getLocaleConfigType_DefaultLocale(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "default-locale",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getLocaleConfigType_SupportedLocale(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "supported-locale",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getLocaleConfigType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (managedBeanClassTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "managed-bean-class_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getManagedBeanClassType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getManagedBeanClassType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (managedBeanNameTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "managed-bean-name_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getManagedBeanNameType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getManagedBeanNameType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (managedBeanScopeTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "managed-bean-scope_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getManagedBeanScopeType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getManagedBeanScopeType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (managedBeanTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "managed-bean_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getManagedBeanType_Description(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "description",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getManagedBeanType_DisplayName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "display-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getManagedBeanType_Icon(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "icon",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getManagedBeanType_ManagedBeanName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "managed-bean-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getManagedBeanType_ManagedBeanClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "managed-bean-class",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getManagedBeanType_ManagedBeanScope(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "managed-bean-scope",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getManagedBeanType_ManagedProperty(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "managed-property",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getManagedBeanType_MapEntries(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "map-entries",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getManagedBeanType_ListEntries(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "list-entries",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getManagedBeanType_ManagedBeanExtension(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "managed-bean-extension",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getManagedBeanType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getManagedBeanType_Eager(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "eager",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (managedBeanExtensionTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "managed-bean-extension_._type"
-		   });		
-		addAnnotation
-		  (managedPropertyTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "managed-property_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getManagedPropertyType_Description(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "description",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getManagedPropertyType_DisplayName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "display-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getManagedPropertyType_Icon(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "icon",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getManagedPropertyType_PropertyName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "property-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getManagedPropertyType_PropertyClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "property-class",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getManagedPropertyType_MapEntries(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "map-entries",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getManagedPropertyType_NullValue(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "null-value",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getManagedPropertyType_Value(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "value",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getManagedPropertyType_ListEntries(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "list-entries",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getManagedPropertyType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (mapEntriesTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "map-entries_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getMapEntriesType_KeyClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "key-class",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getMapEntriesType_ValueClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "value-class",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getMapEntriesType_MapEntry(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "map-entry",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getMapEntriesType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (mapEntryTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "map-entry_._type",
-			 "kind", "empty"
-		   });		
-		addAnnotation
-		  (getMapEntryType_Key(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "key",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getMapEntryType_NullValue(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "null-value",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getMapEntryType_Value(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "value",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getMapEntryType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (messageBundleTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "message-bundle_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getMessageBundleType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getMessageBundleType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (nameTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "name_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getNameType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getNameType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (navigationCaseTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "navigation-case_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getNavigationCaseType_Description(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "description",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getNavigationCaseType_DisplayName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "display-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getNavigationCaseType_Icon(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "icon",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getNavigationCaseType_FromAction(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "from-action",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getNavigationCaseType_FromOutcome(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "from-outcome",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getNavigationCaseType_If(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "if",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getNavigationCaseType_ToViewId(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "to-view-id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getNavigationCaseType_Redirect(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "redirect",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getNavigationCaseType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (navigationHandlerTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "navigation-handler_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getNavigationHandlerType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getNavigationHandlerType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (navigationRuleTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "navigation-rule_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getNavigationRuleType_Description(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "description",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getNavigationRuleType_DisplayName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "display-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getNavigationRuleType_Icon(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "icon",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getNavigationRuleType_FromViewId(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "from-view-id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getNavigationRuleType_NavigationCase(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "navigation-case",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getNavigationRuleType_NavigationRuleExtension(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "navigation-rule-extension",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getNavigationRuleType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (navigationRuleExtensionTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "navigation-rule-extension_._type"
-		   });		
-		addAnnotation
-		  (nullValueTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "null-value_._type",
-			 "kind", "empty"
-		   });		
-		addAnnotation
-		  (getNullValueType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (orderingTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "ordering_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getOrderingType_Before(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "before",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getOrderingType_After(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "after",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (orderingOrderingTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "ordering-ordering_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getOrderingOrderingType_Name(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getOrderingOrderingType_Others(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "others",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (orderingOthersTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "others_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getOrderingOthersType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (partialViewContextFactoryTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "partial-view-context-factory_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getPartialViewContextFactoryType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getPartialViewContextFactoryType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (phaseListenerTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "phase-listener_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getPhaseListenerType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getPhaseListenerType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (propertyClassTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "property-class_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getPropertyClassType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getPropertyClassType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (propertyExtensionTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "property-extension_._type"
-		   });		
-		addAnnotation
-		  (propertyNameTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "property-name_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getPropertyNameType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getPropertyNameType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (propertyResolverTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "property-resolver_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getPropertyResolverType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getPropertyResolverType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (propertyTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "property_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getPropertyType_Description(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "description",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getPropertyType_DisplayName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "display-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getPropertyType_Icon(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "icon",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getPropertyType_PropertyName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "property-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getPropertyType_PropertyClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "property-class",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getPropertyType_DefaultValue(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "default-value",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getPropertyType_SuggestedValue(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "suggested-value",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getPropertyType_PropertyExtension(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "property-extension",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getPropertyType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (redirectTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "redirect_._type",
-			 "kind", "empty"
-		   });		
-		addAnnotation
-		  (getRedirectType_ViewParam(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "view-param",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getRedirectType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getRedirectType_IncludeViewParams(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "include-view-params",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (redirectViewParamTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "redirect-viewParam_._type",
-			 "kind", "empty"
-		   });		
-		addAnnotation
-		  (getRedirectViewParamType_Name(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getRedirectViewParamType_Value(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "value",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getRedirectViewParamType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (referencedBeanClassTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "referenced-bean-class_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getReferencedBeanClassType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getReferencedBeanClassType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (referencedBeanNameTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "referenced-bean-name_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getReferencedBeanNameType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getReferencedBeanNameType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (referencedBeanTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "referenced-bean_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getReferencedBeanType_Description(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "description",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getReferencedBeanType_DisplayName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "display-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getReferencedBeanType_Icon(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "icon",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getReferencedBeanType_ReferencedBeanName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "referenced-bean-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getReferencedBeanType_ReferencedBeanClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "referenced-bean-class",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getReferencedBeanType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (rendererClassTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "renderer-class_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getRendererClassType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getRendererClassType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (rendererExtensionTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "renderer-extension_._type"
-		   });		
-		addAnnotation
-		  (rendererTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "renderer_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getRendererType_Description(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "description",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getRendererType_DisplayName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "display-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getRendererType_Icon(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "icon",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getRendererType_ComponentFamily(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "component-family",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getRendererType_RendererType(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "renderer-type",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getRendererType_RendererClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "renderer-class",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getRendererType_Facet(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "facet",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getRendererType_Attribute(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "attribute",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getRendererType_RendererExtension(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "renderer-extension",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getRendererType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (rendererTypeTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "renderer-type_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getRendererTypeType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getRendererTypeType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (renderKitClassTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "render-kit-class_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getRenderKitClassType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getRenderKitClassType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (renderKitFactoryTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "render-kit-factory_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getRenderKitFactoryType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getRenderKitFactoryType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (renderKitIdTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "render-kit-id_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getRenderKitIdType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getRenderKitIdType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (renderKitTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "render-kit_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getRenderKitType_Description(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "description",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getRenderKitType_DisplayName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "display-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getRenderKitType_Icon(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "icon",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getRenderKitType_RenderKitId(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "render-kit-id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getRenderKitType_RenderKitClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "render-kit-class",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getRenderKitType_Renderer(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "renderer",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getRenderKitType_ClientBehaviorRenderer(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "client-behavior-renderer",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getRenderKitType_RenderKitExtension(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "render-kit-extension",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getRenderKitType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (renderKitExtensionTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "render-kit-extension_._type"
-		   });		
-		addAnnotation
-		  (resourceHandlerTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "resource-handler_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getResourceHandlerType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getResourceHandlerType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (smallIconTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "small-icon_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getSmallIconType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getSmallIconType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (sourceClassTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "source-class_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getSourceClassType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getSourceClassType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (stateManagerTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "state-manager_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getStateManagerType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getStateManagerType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (suggestedValueTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "suggested-value_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getSuggestedValueType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getSuggestedValueType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (supportedLocaleTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "supported-locale_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getSupportedLocaleType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getSupportedLocaleType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (systemEventClassTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "system-event-class_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getSystemEventClassType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getSystemEventClassType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (systemEventListenerClassTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "system-event-listener-class_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getSystemEventListenerClassType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getSystemEventListenerClassType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (systemEventListenerTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "system-event-listener_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getSystemEventListenerType_SystemEventListenerClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "system-event-listener-class",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getSystemEventListenerType_SystemEventClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "system-event-class",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getSystemEventListenerType_SourceClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "source-class",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getSystemEventListenerType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (tagHandlerDelegateFactoryTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "tag-handler-delegate-factory_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getTagHandlerDelegateFactoryType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getTagHandlerDelegateFactoryType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (toViewIdTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "to-view-id_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getToViewIdType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getToViewIdType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (validatorClassTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "validator-class_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getValidatorClassType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getValidatorClassType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (validatorIdTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "validator-id_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getValidatorIdType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getValidatorIdType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (validatorTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "validator_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getValidatorType_Description(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "description",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getValidatorType_DisplayName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "display-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getValidatorType_Icon(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "icon",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getValidatorType_ValidatorId(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "validator-id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getValidatorType_ValidatorClass(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "validator-class",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getValidatorType_Attribute(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "attribute",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getValidatorType_Property(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "property",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getValidatorType_ValidatorExtension(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "validator-extension",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getValidatorType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (validatorExtensionTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "validator-extension_._type"
-		   });		
-		addAnnotation
-		  (valueClassTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "value-class_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getValueClassType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getValueClassType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (valueTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "value_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getValueType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getValueType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (variableResolverTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "variable-resolver_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getVariableResolverType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getVariableResolverType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (viewHandlerTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "view-handler_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getViewHandlerType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getViewHandlerType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (resourceBundleTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "resourceBundle_._type",
-			 "kind", "elementOnly"
-		   });		
-		addAnnotation
-		  (getResourceBundleType_Description(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "description",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getResourceBundleType_DisplayName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "display-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getResourceBundleType_Icon(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "icon",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getResourceBundleType_BaseName(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "base-name",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getResourceBundleType_Var(), 
-		   source, 
-		   new String[] {
-			 "kind", "element",
-			 "name", "var",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (getResourceBundleType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (baseNameTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "base-name_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getBaseNameType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getBaseNameType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (varTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "var_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getVarType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getVarType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (viewDeclarationLanguageFactoryTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "view-declaration-language-factory_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getViewDeclarationLanguageFactoryType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getViewDeclarationLanguageFactoryType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });		
-		addAnnotation
-		  (visitContextFactoryTypeEClass, 
-		   source, 
-		   new String[] {
-			 "name", "visit-context-factory_._type",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getVisitContextFactoryType_TextContent(), 
-		   source, 
-		   new String[] {
-			 "name", ":0",
-			 "kind", "simple"
-		   });		
-		addAnnotation
-		  (getVisitContextFactoryType_Id(), 
-		   source, 
-		   new String[] {
-			 "kind", "attribute",
-			 "name", "id",
-			 "namespace", "##targetNamespace"
-		   });
-	}
-
-} //FacesConfigPackageImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacesConfigTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacesConfigTypeImpl.java
deleted file mode 100644
index e658cf1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacesConfigTypeImpl.java
+++ /dev/null
@@ -1,951 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.EObjectResolvingEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.AbsoluteOrderingType;
-import org.eclipse.jst.jsf.facesconfig.emf.ApplicationType;
-import org.eclipse.jst.jsf.facesconfig.emf.BehaviorType;
-import org.eclipse.jst.jsf.facesconfig.emf.ComponentType;
-import org.eclipse.jst.jsf.facesconfig.emf.ConverterType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType;
-import org.eclipse.jst.jsf.facesconfig.emf.FactoryType;
-import org.eclipse.jst.jsf.facesconfig.emf.LifecycleType;
-import org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType;
-import org.eclipse.jst.jsf.facesconfig.emf.NameType;
-import org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType;
-import org.eclipse.jst.jsf.facesconfig.emf.OrderingType;
-import org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType;
-import org.eclipse.jst.jsf.facesconfig.emf.RenderKitType;
-import org.eclipse.jst.jsf.facesconfig.emf.ValidatorType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl#getApplication <em>Application</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl#getOrdering <em>Ordering</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl#getAbsoluteOrdering <em>Absolute Ordering</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl#getFactory <em>Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl#getComponent <em>Component</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl#getConverter <em>Converter</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl#getManagedBean <em>Managed Bean</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl#getNavigationRule <em>Navigation Rule</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl#getReferencedBean <em>Referenced Bean</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl#getRenderKit <em>Render Kit</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl#getLifecycle <em>Lifecycle</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl#getValidator <em>Validator</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl#getBehavior <em>Behavior</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl#getFacesConfigExtension <em>Faces Config Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl#getXmlns <em>Xmlns</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl#getId <em>Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesConfigTypeImpl#isMetadataComplete <em>Metadata Complete</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class FacesConfigTypeImpl extends EObjectImpl implements FacesConfigType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getApplication() <em>Application</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getApplication()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList application;
-
-    /**
-	 * The cached value of the '{@link #getOrdering() <em>Ordering</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getOrdering()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList ordering;
-
-				/**
-	 * The cached value of the '{@link #getAbsoluteOrdering() <em>Absolute Ordering</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getAbsoluteOrdering()
-	 * @generated
-	 * @ordered
-	 */
-	protected AbsoluteOrderingType absoluteOrdering;
-
-				/**
-	 * The cached value of the '{@link #getFactory() <em>Factory</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getFactory()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList factory;
-
-    /**
-	 * The cached value of the '{@link #getComponent() <em>Component</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getComponent()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList component;
-
-    /**
-	 * The cached value of the '{@link #getConverter() <em>Converter</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getConverter()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList converter;
-
-    /**
-	 * The cached value of the '{@link #getManagedBean() <em>Managed Bean</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getManagedBean()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList managedBean;
-
-    /**
-	 * The cached value of the '{@link #getName() <em>Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getName()
-	 * @generated
-	 * @ordered
-	 */
-	protected NameType name;
-
-				/**
-	 * The cached value of the '{@link #getNavigationRule() <em>Navigation Rule</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getNavigationRule()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList navigationRule;
-
-    /**
-	 * The cached value of the '{@link #getReferencedBean() <em>Referenced Bean</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getReferencedBean()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList referencedBean;
-
-    /**
-	 * The cached value of the '{@link #getRenderKit() <em>Render Kit</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getRenderKit()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList renderKit;
-
-    /**
-	 * The cached value of the '{@link #getLifecycle() <em>Lifecycle</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getLifecycle()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList lifecycle;
-
-    /**
-	 * The cached value of the '{@link #getValidator() <em>Validator</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getValidator()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList validator;
-
-    /**
-	 * The cached value of the '{@link #getBehavior() <em>Behavior</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getBehavior()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList behavior;
-
-				/**
-	 * The cached value of the '{@link #getFacesConfigExtension() <em>Faces Config Extension</em>}' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getFacesConfigExtension()
-	 * @generated
-	 * @ordered
-	 */
-    protected EList facesConfigExtension;
-
-    /**
-	 * The default value of the '{@link #getXmlns() <em>Xmlns</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getXmlns()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String XMLNS_EDEFAULT = "http://java.sun.com/JSF/Configuration"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getXmlns() <em>Xmlns</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getXmlns()
-	 * @generated
-	 * @ordered
-	 */
-	protected String xmlns = XMLNS_EDEFAULT;
-
-    /**
-	 * This is true if the Xmlns attribute has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected boolean xmlnsESet;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #isMetadataComplete() <em>Metadata Complete</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isMetadataComplete()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean METADATA_COMPLETE_EDEFAULT = false;
-
-				/**
-	 * The cached value of the '{@link #isMetadataComplete() <em>Metadata Complete</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isMetadataComplete()
-	 * @generated
-	 * @ordered
-	 */
-	protected boolean metadataComplete = METADATA_COMPLETE_EDEFAULT;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected FacesConfigTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.FACES_CONFIG_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getApplication() {
-		if (application == null) {
-			application = new EObjectContainmentEList(ApplicationType.class, this, FacesConfigPackage.FACES_CONFIG_TYPE__APPLICATION);
-		}
-		return application;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getOrdering() {
-		if (ordering == null) {
-			ordering = new EObjectContainmentEList(OrderingType.class, this, FacesConfigPackage.FACES_CONFIG_TYPE__ORDERING);
-		}
-		return ordering;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public AbsoluteOrderingType getAbsoluteOrdering() {
-		return absoluteOrdering;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newAbsoluteOrdering 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetAbsoluteOrdering(AbsoluteOrderingType newAbsoluteOrdering, NotificationChain msgs) {
-		AbsoluteOrderingType oldAbsoluteOrdering = absoluteOrdering;
-		absoluteOrdering = newAbsoluteOrdering;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.FACES_CONFIG_TYPE__ABSOLUTE_ORDERING, oldAbsoluteOrdering, newAbsoluteOrdering);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setAbsoluteOrdering(AbsoluteOrderingType newAbsoluteOrdering) {
-		if (newAbsoluteOrdering != absoluteOrdering) {
-			NotificationChain msgs = null;
-			if (absoluteOrdering != null)
-				msgs = ((InternalEObject)absoluteOrdering).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.FACES_CONFIG_TYPE__ABSOLUTE_ORDERING, null, msgs);
-			if (newAbsoluteOrdering != null)
-				msgs = ((InternalEObject)newAbsoluteOrdering).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.FACES_CONFIG_TYPE__ABSOLUTE_ORDERING, null, msgs);
-			msgs = basicSetAbsoluteOrdering(newAbsoluteOrdering, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.FACES_CONFIG_TYPE__ABSOLUTE_ORDERING, newAbsoluteOrdering, newAbsoluteOrdering));
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getFactory() {
-		if (factory == null) {
-			factory = new EObjectContainmentEList(FactoryType.class, this, FacesConfigPackage.FACES_CONFIG_TYPE__FACTORY);
-		}
-		return factory;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getComponent() {
-		if (component == null) {
-			component = new EObjectContainmentEList(ComponentType.class, this, FacesConfigPackage.FACES_CONFIG_TYPE__COMPONENT);
-		}
-		return component;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getConverter() {
-		if (converter == null) {
-			converter = new EObjectContainmentEList(ConverterType.class, this, FacesConfigPackage.FACES_CONFIG_TYPE__CONVERTER);
-		}
-		return converter;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getManagedBean() {
-		if (managedBean == null) {
-			managedBean = new EObjectContainmentEList(ManagedBeanType.class, this, FacesConfigPackage.FACES_CONFIG_TYPE__MANAGED_BEAN);
-		}
-		return managedBean;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NameType getName() {
-		return name;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * @param newName 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetName(NameType newName, NotificationChain msgs) {
-		NameType oldName = name;
-		name = newName;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.FACES_CONFIG_TYPE__NAME, oldName, newName);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setName(NameType newName) {
-		if (newName != name) {
-			NotificationChain msgs = null;
-			if (name != null)
-				msgs = ((InternalEObject)name).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.FACES_CONFIG_TYPE__NAME, null, msgs);
-			if (newName != null)
-				msgs = ((InternalEObject)newName).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.FACES_CONFIG_TYPE__NAME, null, msgs);
-			msgs = basicSetName(newName, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.FACES_CONFIG_TYPE__NAME, newName, newName));
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getNavigationRule() {
-		if (navigationRule == null) {
-			navigationRule = new EObjectContainmentEList(NavigationRuleType.class, this, FacesConfigPackage.FACES_CONFIG_TYPE__NAVIGATION_RULE);
-		}
-		return navigationRule;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getReferencedBean() {
-		if (referencedBean == null) {
-			referencedBean = new EObjectContainmentEList(ReferencedBeanType.class, this, FacesConfigPackage.FACES_CONFIG_TYPE__REFERENCED_BEAN);
-		}
-		return referencedBean;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getRenderKit() {
-		if (renderKit == null) {
-			renderKit = new EObjectContainmentEList(RenderKitType.class, this, FacesConfigPackage.FACES_CONFIG_TYPE__RENDER_KIT);
-		}
-		return renderKit;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getLifecycle() {
-		if (lifecycle == null) {
-			lifecycle = new EObjectContainmentEList(LifecycleType.class, this, FacesConfigPackage.FACES_CONFIG_TYPE__LIFECYCLE);
-		}
-		return lifecycle;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getValidator() {
-		if (validator == null) {
-			validator = new EObjectContainmentEList(ValidatorType.class, this, FacesConfigPackage.FACES_CONFIG_TYPE__VALIDATOR);
-		}
-		return validator;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getBehavior() {
-		if (behavior == null) {
-			behavior = new EObjectContainmentEList(BehaviorType.class, this, FacesConfigPackage.FACES_CONFIG_TYPE__BEHAVIOR);
-		}
-		return behavior;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EList getFacesConfigExtension() {
-		if (facesConfigExtension == null) {
-			facesConfigExtension = new EObjectResolvingEList(FacesConfigExtensionType.class, this, FacesConfigPackage.FACES_CONFIG_TYPE__FACES_CONFIG_EXTENSION);
-		}
-		return facesConfigExtension;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getXmlns() {
-		return xmlns;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setXmlns(String newXmlns) {
-		String oldXmlns = xmlns;
-		xmlns = newXmlns;
-		boolean oldXmlnsESet = xmlnsESet;
-		xmlnsESet = true;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.FACES_CONFIG_TYPE__XMLNS, oldXmlns, xmlns, !oldXmlnsESet));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetXmlns() {
-		String oldXmlns = xmlns;
-		boolean oldXmlnsESet = xmlnsESet;
-		xmlns = XMLNS_EDEFAULT;
-		xmlnsESet = false;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, FacesConfigPackage.FACES_CONFIG_TYPE__XMLNS, oldXmlns, XMLNS_EDEFAULT, oldXmlnsESet));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetXmlns() {
-		return xmlnsESet;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.FACES_CONFIG_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isMetadataComplete() {
-		return metadataComplete;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setMetadataComplete(boolean newMetadataComplete) {
-		boolean oldMetadataComplete = metadataComplete;
-		metadataComplete = newMetadataComplete;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.FACES_CONFIG_TYPE__METADATA_COMPLETE, oldMetadataComplete, metadataComplete));
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.FACES_CONFIG_TYPE__APPLICATION:
-				return ((InternalEList)getApplication()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACES_CONFIG_TYPE__ORDERING:
-				return ((InternalEList)getOrdering()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACES_CONFIG_TYPE__ABSOLUTE_ORDERING:
-				return basicSetAbsoluteOrdering(null, msgs);
-			case FacesConfigPackage.FACES_CONFIG_TYPE__FACTORY:
-				return ((InternalEList)getFactory()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACES_CONFIG_TYPE__COMPONENT:
-				return ((InternalEList)getComponent()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACES_CONFIG_TYPE__CONVERTER:
-				return ((InternalEList)getConverter()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACES_CONFIG_TYPE__MANAGED_BEAN:
-				return ((InternalEList)getManagedBean()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACES_CONFIG_TYPE__NAME:
-				return basicSetName(null, msgs);
-			case FacesConfigPackage.FACES_CONFIG_TYPE__NAVIGATION_RULE:
-				return ((InternalEList)getNavigationRule()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACES_CONFIG_TYPE__REFERENCED_BEAN:
-				return ((InternalEList)getReferencedBean()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACES_CONFIG_TYPE__RENDER_KIT:
-				return ((InternalEList)getRenderKit()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACES_CONFIG_TYPE__LIFECYCLE:
-				return ((InternalEList)getLifecycle()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACES_CONFIG_TYPE__VALIDATOR:
-				return ((InternalEList)getValidator()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACES_CONFIG_TYPE__BEHAVIOR:
-				return ((InternalEList)getBehavior()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.FACES_CONFIG_TYPE__APPLICATION:
-				return getApplication();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__ORDERING:
-				return getOrdering();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__ABSOLUTE_ORDERING:
-				return getAbsoluteOrdering();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__FACTORY:
-				return getFactory();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__COMPONENT:
-				return getComponent();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__CONVERTER:
-				return getConverter();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__MANAGED_BEAN:
-				return getManagedBean();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__NAME:
-				return getName();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__NAVIGATION_RULE:
-				return getNavigationRule();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__REFERENCED_BEAN:
-				return getReferencedBean();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__RENDER_KIT:
-				return getRenderKit();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__LIFECYCLE:
-				return getLifecycle();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__VALIDATOR:
-				return getValidator();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__BEHAVIOR:
-				return getBehavior();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__FACES_CONFIG_EXTENSION:
-				return getFacesConfigExtension();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__XMLNS:
-				return getXmlns();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__ID:
-				return getId();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__METADATA_COMPLETE:
-				return isMetadataComplete() ? Boolean.TRUE : Boolean.FALSE;
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.FACES_CONFIG_TYPE__APPLICATION:
-				getApplication().clear();
-				getApplication().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__ORDERING:
-				getOrdering().clear();
-				getOrdering().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__ABSOLUTE_ORDERING:
-				setAbsoluteOrdering((AbsoluteOrderingType)newValue);
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__FACTORY:
-				getFactory().clear();
-				getFactory().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__COMPONENT:
-				getComponent().clear();
-				getComponent().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__CONVERTER:
-				getConverter().clear();
-				getConverter().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__MANAGED_BEAN:
-				getManagedBean().clear();
-				getManagedBean().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__NAME:
-				setName((NameType)newValue);
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__NAVIGATION_RULE:
-				getNavigationRule().clear();
-				getNavigationRule().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__REFERENCED_BEAN:
-				getReferencedBean().clear();
-				getReferencedBean().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__RENDER_KIT:
-				getRenderKit().clear();
-				getRenderKit().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__LIFECYCLE:
-				getLifecycle().clear();
-				getLifecycle().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__VALIDATOR:
-				getValidator().clear();
-				getValidator().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__BEHAVIOR:
-				getBehavior().clear();
-				getBehavior().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__FACES_CONFIG_EXTENSION:
-				getFacesConfigExtension().clear();
-				getFacesConfigExtension().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__XMLNS:
-				setXmlns((String)newValue);
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__ID:
-				setId((String)newValue);
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__METADATA_COMPLETE:
-				setMetadataComplete(((Boolean)newValue).booleanValue());
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.FACES_CONFIG_TYPE__APPLICATION:
-				getApplication().clear();
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__ORDERING:
-				getOrdering().clear();
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__ABSOLUTE_ORDERING:
-				setAbsoluteOrdering((AbsoluteOrderingType)null);
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__FACTORY:
-				getFactory().clear();
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__COMPONENT:
-				getComponent().clear();
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__CONVERTER:
-				getConverter().clear();
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__MANAGED_BEAN:
-				getManagedBean().clear();
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__NAME:
-				setName((NameType)null);
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__NAVIGATION_RULE:
-				getNavigationRule().clear();
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__REFERENCED_BEAN:
-				getReferencedBean().clear();
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__RENDER_KIT:
-				getRenderKit().clear();
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__LIFECYCLE:
-				getLifecycle().clear();
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__VALIDATOR:
-				getValidator().clear();
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__BEHAVIOR:
-				getBehavior().clear();
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__FACES_CONFIG_EXTENSION:
-				getFacesConfigExtension().clear();
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__XMLNS:
-				unsetXmlns();
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__METADATA_COMPLETE:
-				setMetadataComplete(METADATA_COMPLETE_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.FACES_CONFIG_TYPE__APPLICATION:
-				return application != null && !application.isEmpty();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__ORDERING:
-				return ordering != null && !ordering.isEmpty();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__ABSOLUTE_ORDERING:
-				return absoluteOrdering != null;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__FACTORY:
-				return factory != null && !factory.isEmpty();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__COMPONENT:
-				return component != null && !component.isEmpty();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__CONVERTER:
-				return converter != null && !converter.isEmpty();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__MANAGED_BEAN:
-				return managedBean != null && !managedBean.isEmpty();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__NAME:
-				return name != null;
-			case FacesConfigPackage.FACES_CONFIG_TYPE__NAVIGATION_RULE:
-				return navigationRule != null && !navigationRule.isEmpty();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__REFERENCED_BEAN:
-				return referencedBean != null && !referencedBean.isEmpty();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__RENDER_KIT:
-				return renderKit != null && !renderKit.isEmpty();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__LIFECYCLE:
-				return lifecycle != null && !lifecycle.isEmpty();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__VALIDATOR:
-				return validator != null && !validator.isEmpty();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__BEHAVIOR:
-				return behavior != null && !behavior.isEmpty();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__FACES_CONFIG_EXTENSION:
-				return facesConfigExtension != null && !facesConfigExtension.isEmpty();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__XMLNS:
-				return isSetXmlns();
-			case FacesConfigPackage.FACES_CONFIG_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-			case FacesConfigPackage.FACES_CONFIG_TYPE__METADATA_COMPLETE:
-				return metadataComplete != METADATA_COMPLETE_EDEFAULT;
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (xmlns: "); //$NON-NLS-1$
-		if (xmlnsESet) result.append(xmlns); else result.append("<unset>"); //$NON-NLS-1$
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(", metadataComplete: "); //$NON-NLS-1$
-		result.append(metadataComplete);
-		result.append(')');
-		return result.toString();
-	}
-
-} //FacesConfigTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacesContextFactoryTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacesContextFactoryTypeImpl.java
deleted file mode 100644
index 4ab342a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacesContextFactoryTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesContextFactoryType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Faces Context Factory Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesContextFactoryTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacesContextFactoryTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class FacesContextFactoryTypeImpl extends EObjectImpl implements FacesContextFactoryType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected FacesContextFactoryTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.FACES_CONTEXT_FACTORY_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.FACES_CONTEXT_FACTORY_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.FACES_CONTEXT_FACTORY_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.FACES_CONTEXT_FACTORY_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.FACES_CONTEXT_FACTORY_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.FACES_CONTEXT_FACTORY_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.FACES_CONTEXT_FACTORY_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.FACES_CONTEXT_FACTORY_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.FACES_CONTEXT_FACTORY_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.FACES_CONTEXT_FACTORY_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.FACES_CONTEXT_FACTORY_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //FacesContextFactoryTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacetExtensionTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacetExtensionTypeImpl.java
deleted file mode 100644
index 6e99b46..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacetExtensionTypeImpl.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FacetExtensionType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Facet Extension Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * </p>
- *
- * @generated
- */
-public class FacetExtensionTypeImpl extends ExtensionTypeImpl implements FacetExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected FacetExtensionTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.FACET_EXTENSION_TYPE;
-	}
-
-} //FacetExtensionTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacetNameTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacetNameTypeImpl.java
deleted file mode 100644
index cab6a24..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacetNameTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FacetNameType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Facet Name Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacetNameTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacetNameTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class FacetNameTypeImpl extends EObjectImpl implements FacetNameType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected FacetNameTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.FACET_NAME_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.FACET_NAME_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.FACET_NAME_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.FACET_NAME_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.FACET_NAME_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.FACET_NAME_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.FACET_NAME_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.FACET_NAME_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.FACET_NAME_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.FACET_NAME_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.FACET_NAME_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //FacetNameTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacetTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacetTypeImpl.java
deleted file mode 100644
index 5d5e586..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FacetTypeImpl.java
+++ /dev/null
@@ -1,407 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.DescriptionType;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FacetExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacetNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacetType;
-import org.eclipse.jst.jsf.facesconfig.emf.IconType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Facet Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacetTypeImpl#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacetTypeImpl#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacetTypeImpl#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacetTypeImpl#getFacetName <em>Facet Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacetTypeImpl#getFacetExtension <em>Facet Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FacetTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class FacetTypeImpl extends EObjectImpl implements FacetType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getDescription() <em>Description</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDescription()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList description;
-
-    /**
-	 * The cached value of the '{@link #getDisplayName() <em>Display Name</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDisplayName()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList displayName;
-
-    /**
-	 * The cached value of the '{@link #getIcon() <em>Icon</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getIcon()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList icon;
-
-    /**
-	 * The cached value of the '{@link #getFacetName() <em>Facet Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getFacetName()
-	 * @generated
-	 * @ordered
-	 */
-	protected FacetNameType facetName;
-
-    /**
-	 * The cached value of the '{@link #getFacetExtension() <em>Facet Extension</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getFacetExtension()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList facetExtension;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected FacetTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.FACET_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDescription() {
-		if (description == null) {
-			description = new EObjectContainmentEList(DescriptionType.class, this, FacesConfigPackage.FACET_TYPE__DESCRIPTION);
-		}
-		return description;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDisplayName() {
-		if (displayName == null) {
-			displayName = new EObjectContainmentEList(DisplayNameType.class, this, FacesConfigPackage.FACET_TYPE__DISPLAY_NAME);
-		}
-		return displayName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getIcon() {
-		if (icon == null) {
-			icon = new EObjectContainmentEList(IconType.class, this, FacesConfigPackage.FACET_TYPE__ICON);
-		}
-		return icon;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FacetNameType getFacetName() {
-		return facetName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newFacetName 
-     * @param msgs 
-     * @return NotificationChain
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetFacetName(FacetNameType newFacetName, NotificationChain msgs) {
-		FacetNameType oldFacetName = facetName;
-		facetName = newFacetName;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.FACET_TYPE__FACET_NAME, oldFacetName, newFacetName);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setFacetName(FacetNameType newFacetName) {
-		if (newFacetName != facetName) {
-			NotificationChain msgs = null;
-			if (facetName != null)
-				msgs = ((InternalEObject)facetName).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.FACET_TYPE__FACET_NAME, null, msgs);
-			if (newFacetName != null)
-				msgs = ((InternalEObject)newFacetName).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.FACET_TYPE__FACET_NAME, null, msgs);
-			msgs = basicSetFacetName(newFacetName, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.FACET_TYPE__FACET_NAME, newFacetName, newFacetName));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getFacetExtension() {
-		if (facetExtension == null) {
-			facetExtension = new EObjectContainmentEList(FacetExtensionType.class, this, FacesConfigPackage.FACET_TYPE__FACET_EXTENSION);
-		}
-		return facetExtension;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.FACET_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.FACET_TYPE__DESCRIPTION:
-				return ((InternalEList)getDescription()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACET_TYPE__DISPLAY_NAME:
-				return ((InternalEList)getDisplayName()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACET_TYPE__ICON:
-				return ((InternalEList)getIcon()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACET_TYPE__FACET_NAME:
-				return basicSetFacetName(null, msgs);
-			case FacesConfigPackage.FACET_TYPE__FACET_EXTENSION:
-				return ((InternalEList)getFacetExtension()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.FACET_TYPE__DESCRIPTION:
-				return getDescription();
-			case FacesConfigPackage.FACET_TYPE__DISPLAY_NAME:
-				return getDisplayName();
-			case FacesConfigPackage.FACET_TYPE__ICON:
-				return getIcon();
-			case FacesConfigPackage.FACET_TYPE__FACET_NAME:
-				return getFacetName();
-			case FacesConfigPackage.FACET_TYPE__FACET_EXTENSION:
-				return getFacetExtension();
-			case FacesConfigPackage.FACET_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.FACET_TYPE__DESCRIPTION:
-				getDescription().clear();
-				getDescription().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACET_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				getDisplayName().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACET_TYPE__ICON:
-				getIcon().clear();
-				getIcon().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACET_TYPE__FACET_NAME:
-				setFacetName((FacetNameType)newValue);
-				return;
-			case FacesConfigPackage.FACET_TYPE__FACET_EXTENSION:
-				getFacetExtension().clear();
-				getFacetExtension().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACET_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.FACET_TYPE__DESCRIPTION:
-				getDescription().clear();
-				return;
-			case FacesConfigPackage.FACET_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				return;
-			case FacesConfigPackage.FACET_TYPE__ICON:
-				getIcon().clear();
-				return;
-			case FacesConfigPackage.FACET_TYPE__FACET_NAME:
-				setFacetName((FacetNameType)null);
-				return;
-			case FacesConfigPackage.FACET_TYPE__FACET_EXTENSION:
-				getFacetExtension().clear();
-				return;
-			case FacesConfigPackage.FACET_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.FACET_TYPE__DESCRIPTION:
-				return description != null && !description.isEmpty();
-			case FacesConfigPackage.FACET_TYPE__DISPLAY_NAME:
-				return displayName != null && !displayName.isEmpty();
-			case FacesConfigPackage.FACET_TYPE__ICON:
-				return icon != null && !icon.isEmpty();
-			case FacesConfigPackage.FACET_TYPE__FACET_NAME:
-				return facetName != null;
-			case FacesConfigPackage.FACET_TYPE__FACET_EXTENSION:
-				return facetExtension != null && !facetExtension.isEmpty();
-			case FacesConfigPackage.FACET_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //FacetTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FactoryExtensionTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FactoryExtensionTypeImpl.java
deleted file mode 100644
index 6bec8fd..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FactoryExtensionTypeImpl.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FactoryExtensionType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Factory Extension Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * </p>
- *
- * @generated
- */
-public class FactoryExtensionTypeImpl extends ExtensionTypeImpl implements FactoryExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    @SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected FactoryExtensionTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.FACTORY_EXTENSION_TYPE;
-	}
-
-} //FactoryExtensionTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FactoryTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FactoryTypeImpl.java
deleted file mode 100644
index e7b00cf..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FactoryTypeImpl.java
+++ /dev/null
@@ -1,595 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.EObjectResolvingEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.ApplicationFactoryType;
-import org.eclipse.jst.jsf.facesconfig.emf.ExceptionHandlerFactoryType;
-import org.eclipse.jst.jsf.facesconfig.emf.ExternalContextFactoryType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesContextFactoryType;
-import org.eclipse.jst.jsf.facesconfig.emf.FactoryExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.FactoryType;
-import org.eclipse.jst.jsf.facesconfig.emf.LifecycleFactoryType;
-import org.eclipse.jst.jsf.facesconfig.emf.PartialViewContextFactoryType;
-import org.eclipse.jst.jsf.facesconfig.emf.RenderKitFactoryType;
-import org.eclipse.jst.jsf.facesconfig.emf.TagHandlerDelegateFactoryType;
-import org.eclipse.jst.jsf.facesconfig.emf.ViewDeclarationLanguageFactoryType;
-import org.eclipse.jst.jsf.facesconfig.emf.VisitContextFactoryType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Factory Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryTypeImpl#getApplicationFactory <em>Application Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryTypeImpl#getExceptionHandlerFactory <em>Exception Handler Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryTypeImpl#getExternalContextFactory <em>External Context Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryTypeImpl#getFacesContextFactory <em>Faces Context Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryTypeImpl#getPartialViewContextFactory <em>Partial View Context Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryTypeImpl#getLifecycleFactory <em>Lifecycle Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryTypeImpl#getViewDeclarationLanguageFactory <em>View Declaration Language Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryTypeImpl#getTagHandlerDelegateFactory <em>Tag Handler Delegate Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryTypeImpl#getRenderKitFactory <em>Render Kit Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryTypeImpl#getVisitContextFactory <em>Visit Context Factory</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryTypeImpl#getFactoryExtension <em>Factory Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FactoryTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class FactoryTypeImpl extends EObjectImpl implements FactoryType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getApplicationFactory() <em>Application Factory</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getApplicationFactory()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList applicationFactory;
-
-    /**
-	 * The cached value of the '{@link #getExceptionHandlerFactory() <em>Exception Handler Factory</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getExceptionHandlerFactory()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList exceptionHandlerFactory;
-
-				/**
-	 * The cached value of the '{@link #getExternalContextFactory() <em>External Context Factory</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getExternalContextFactory()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList externalContextFactory;
-
-				/**
-	 * The cached value of the '{@link #getFacesContextFactory() <em>Faces Context Factory</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getFacesContextFactory()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList facesContextFactory;
-
-    /**
-	 * The cached value of the '{@link #getPartialViewContextFactory() <em>Partial View Context Factory</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getPartialViewContextFactory()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList partialViewContextFactory;
-
-				/**
-	 * The cached value of the '{@link #getLifecycleFactory() <em>Lifecycle Factory</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getLifecycleFactory()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList lifecycleFactory;
-
-    /**
-	 * The cached value of the '{@link #getViewDeclarationLanguageFactory() <em>View Declaration Language Factory</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getViewDeclarationLanguageFactory()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList viewDeclarationLanguageFactory;
-
-				/**
-	 * The cached value of the '{@link #getTagHandlerDelegateFactory() <em>Tag Handler Delegate Factory</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTagHandlerDelegateFactory()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList tagHandlerDelegateFactory;
-
-				/**
-	 * The cached value of the '{@link #getRenderKitFactory() <em>Render Kit Factory</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getRenderKitFactory()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList renderKitFactory;
-
-    /**
-	 * The cached value of the '{@link #getVisitContextFactory() <em>Visit Context Factory</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getVisitContextFactory()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList visitContextFactory;
-
-				/**
-	 * The cached value of the '{@link #getFactoryExtension() <em>Factory Extension</em>}' reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getFactoryExtension()
-	 * @generated
-	 * @ordered
-	 */
-    protected EList factoryExtension;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected FactoryTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.FACTORY_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getApplicationFactory() {
-		if (applicationFactory == null) {
-			applicationFactory = new EObjectContainmentEList(ApplicationFactoryType.class, this, FacesConfigPackage.FACTORY_TYPE__APPLICATION_FACTORY);
-		}
-		return applicationFactory;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getExceptionHandlerFactory() {
-		if (exceptionHandlerFactory == null) {
-			exceptionHandlerFactory = new EObjectContainmentEList(ExceptionHandlerFactoryType.class, this, FacesConfigPackage.FACTORY_TYPE__EXCEPTION_HANDLER_FACTORY);
-		}
-		return exceptionHandlerFactory;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getExternalContextFactory() {
-		if (externalContextFactory == null) {
-			externalContextFactory = new EObjectContainmentEList(ExternalContextFactoryType.class, this, FacesConfigPackage.FACTORY_TYPE__EXTERNAL_CONTEXT_FACTORY);
-		}
-		return externalContextFactory;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getFacesContextFactory() {
-		if (facesContextFactory == null) {
-			facesContextFactory = new EObjectContainmentEList(FacesContextFactoryType.class, this, FacesConfigPackage.FACTORY_TYPE__FACES_CONTEXT_FACTORY);
-		}
-		return facesContextFactory;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getPartialViewContextFactory() {
-		if (partialViewContextFactory == null) {
-			partialViewContextFactory = new EObjectContainmentEList(PartialViewContextFactoryType.class, this, FacesConfigPackage.FACTORY_TYPE__PARTIAL_VIEW_CONTEXT_FACTORY);
-		}
-		return partialViewContextFactory;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getLifecycleFactory() {
-		if (lifecycleFactory == null) {
-			lifecycleFactory = new EObjectContainmentEList(LifecycleFactoryType.class, this, FacesConfigPackage.FACTORY_TYPE__LIFECYCLE_FACTORY);
-		}
-		return lifecycleFactory;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getViewDeclarationLanguageFactory() {
-		if (viewDeclarationLanguageFactory == null) {
-			viewDeclarationLanguageFactory = new EObjectContainmentEList(ViewDeclarationLanguageFactoryType.class, this, FacesConfigPackage.FACTORY_TYPE__VIEW_DECLARATION_LANGUAGE_FACTORY);
-		}
-		return viewDeclarationLanguageFactory;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getTagHandlerDelegateFactory() {
-		if (tagHandlerDelegateFactory == null) {
-			tagHandlerDelegateFactory = new EObjectContainmentEList(TagHandlerDelegateFactoryType.class, this, FacesConfigPackage.FACTORY_TYPE__TAG_HANDLER_DELEGATE_FACTORY);
-		}
-		return tagHandlerDelegateFactory;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getRenderKitFactory() {
-		if (renderKitFactory == null) {
-			renderKitFactory = new EObjectContainmentEList(RenderKitFactoryType.class, this, FacesConfigPackage.FACTORY_TYPE__RENDER_KIT_FACTORY);
-		}
-		return renderKitFactory;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getVisitContextFactory() {
-		if (visitContextFactory == null) {
-			visitContextFactory = new EObjectContainmentEList(VisitContextFactoryType.class, this, FacesConfigPackage.FACTORY_TYPE__VISIT_CONTEXT_FACTORY);
-		}
-		return visitContextFactory;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EList getFactoryExtension() {
-		if (factoryExtension == null) {
-			factoryExtension = new EObjectResolvingEList(FactoryExtensionType.class, this, FacesConfigPackage.FACTORY_TYPE__FACTORY_EXTENSION);
-		}
-		return factoryExtension;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.FACTORY_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.FACTORY_TYPE__APPLICATION_FACTORY:
-				return ((InternalEList)getApplicationFactory()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACTORY_TYPE__EXCEPTION_HANDLER_FACTORY:
-				return ((InternalEList)getExceptionHandlerFactory()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACTORY_TYPE__EXTERNAL_CONTEXT_FACTORY:
-				return ((InternalEList)getExternalContextFactory()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACTORY_TYPE__FACES_CONTEXT_FACTORY:
-				return ((InternalEList)getFacesContextFactory()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACTORY_TYPE__PARTIAL_VIEW_CONTEXT_FACTORY:
-				return ((InternalEList)getPartialViewContextFactory()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACTORY_TYPE__LIFECYCLE_FACTORY:
-				return ((InternalEList)getLifecycleFactory()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACTORY_TYPE__VIEW_DECLARATION_LANGUAGE_FACTORY:
-				return ((InternalEList)getViewDeclarationLanguageFactory()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACTORY_TYPE__TAG_HANDLER_DELEGATE_FACTORY:
-				return ((InternalEList)getTagHandlerDelegateFactory()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACTORY_TYPE__RENDER_KIT_FACTORY:
-				return ((InternalEList)getRenderKitFactory()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.FACTORY_TYPE__VISIT_CONTEXT_FACTORY:
-				return ((InternalEList)getVisitContextFactory()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.FACTORY_TYPE__APPLICATION_FACTORY:
-				return getApplicationFactory();
-			case FacesConfigPackage.FACTORY_TYPE__EXCEPTION_HANDLER_FACTORY:
-				return getExceptionHandlerFactory();
-			case FacesConfigPackage.FACTORY_TYPE__EXTERNAL_CONTEXT_FACTORY:
-				return getExternalContextFactory();
-			case FacesConfigPackage.FACTORY_TYPE__FACES_CONTEXT_FACTORY:
-				return getFacesContextFactory();
-			case FacesConfigPackage.FACTORY_TYPE__PARTIAL_VIEW_CONTEXT_FACTORY:
-				return getPartialViewContextFactory();
-			case FacesConfigPackage.FACTORY_TYPE__LIFECYCLE_FACTORY:
-				return getLifecycleFactory();
-			case FacesConfigPackage.FACTORY_TYPE__VIEW_DECLARATION_LANGUAGE_FACTORY:
-				return getViewDeclarationLanguageFactory();
-			case FacesConfigPackage.FACTORY_TYPE__TAG_HANDLER_DELEGATE_FACTORY:
-				return getTagHandlerDelegateFactory();
-			case FacesConfigPackage.FACTORY_TYPE__RENDER_KIT_FACTORY:
-				return getRenderKitFactory();
-			case FacesConfigPackage.FACTORY_TYPE__VISIT_CONTEXT_FACTORY:
-				return getVisitContextFactory();
-			case FacesConfigPackage.FACTORY_TYPE__FACTORY_EXTENSION:
-				return getFactoryExtension();
-			case FacesConfigPackage.FACTORY_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.FACTORY_TYPE__APPLICATION_FACTORY:
-				getApplicationFactory().clear();
-				getApplicationFactory().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__EXCEPTION_HANDLER_FACTORY:
-				getExceptionHandlerFactory().clear();
-				getExceptionHandlerFactory().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__EXTERNAL_CONTEXT_FACTORY:
-				getExternalContextFactory().clear();
-				getExternalContextFactory().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__FACES_CONTEXT_FACTORY:
-				getFacesContextFactory().clear();
-				getFacesContextFactory().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__PARTIAL_VIEW_CONTEXT_FACTORY:
-				getPartialViewContextFactory().clear();
-				getPartialViewContextFactory().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__LIFECYCLE_FACTORY:
-				getLifecycleFactory().clear();
-				getLifecycleFactory().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__VIEW_DECLARATION_LANGUAGE_FACTORY:
-				getViewDeclarationLanguageFactory().clear();
-				getViewDeclarationLanguageFactory().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__TAG_HANDLER_DELEGATE_FACTORY:
-				getTagHandlerDelegateFactory().clear();
-				getTagHandlerDelegateFactory().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__RENDER_KIT_FACTORY:
-				getRenderKitFactory().clear();
-				getRenderKitFactory().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__VISIT_CONTEXT_FACTORY:
-				getVisitContextFactory().clear();
-				getVisitContextFactory().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__FACTORY_EXTENSION:
-				getFactoryExtension().clear();
-				getFactoryExtension().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.FACTORY_TYPE__APPLICATION_FACTORY:
-				getApplicationFactory().clear();
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__EXCEPTION_HANDLER_FACTORY:
-				getExceptionHandlerFactory().clear();
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__EXTERNAL_CONTEXT_FACTORY:
-				getExternalContextFactory().clear();
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__FACES_CONTEXT_FACTORY:
-				getFacesContextFactory().clear();
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__PARTIAL_VIEW_CONTEXT_FACTORY:
-				getPartialViewContextFactory().clear();
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__LIFECYCLE_FACTORY:
-				getLifecycleFactory().clear();
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__VIEW_DECLARATION_LANGUAGE_FACTORY:
-				getViewDeclarationLanguageFactory().clear();
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__TAG_HANDLER_DELEGATE_FACTORY:
-				getTagHandlerDelegateFactory().clear();
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__RENDER_KIT_FACTORY:
-				getRenderKitFactory().clear();
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__VISIT_CONTEXT_FACTORY:
-				getVisitContextFactory().clear();
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__FACTORY_EXTENSION:
-				getFactoryExtension().clear();
-				return;
-			case FacesConfigPackage.FACTORY_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.FACTORY_TYPE__APPLICATION_FACTORY:
-				return applicationFactory != null && !applicationFactory.isEmpty();
-			case FacesConfigPackage.FACTORY_TYPE__EXCEPTION_HANDLER_FACTORY:
-				return exceptionHandlerFactory != null && !exceptionHandlerFactory.isEmpty();
-			case FacesConfigPackage.FACTORY_TYPE__EXTERNAL_CONTEXT_FACTORY:
-				return externalContextFactory != null && !externalContextFactory.isEmpty();
-			case FacesConfigPackage.FACTORY_TYPE__FACES_CONTEXT_FACTORY:
-				return facesContextFactory != null && !facesContextFactory.isEmpty();
-			case FacesConfigPackage.FACTORY_TYPE__PARTIAL_VIEW_CONTEXT_FACTORY:
-				return partialViewContextFactory != null && !partialViewContextFactory.isEmpty();
-			case FacesConfigPackage.FACTORY_TYPE__LIFECYCLE_FACTORY:
-				return lifecycleFactory != null && !lifecycleFactory.isEmpty();
-			case FacesConfigPackage.FACTORY_TYPE__VIEW_DECLARATION_LANGUAGE_FACTORY:
-				return viewDeclarationLanguageFactory != null && !viewDeclarationLanguageFactory.isEmpty();
-			case FacesConfigPackage.FACTORY_TYPE__TAG_HANDLER_DELEGATE_FACTORY:
-				return tagHandlerDelegateFactory != null && !tagHandlerDelegateFactory.isEmpty();
-			case FacesConfigPackage.FACTORY_TYPE__RENDER_KIT_FACTORY:
-				return renderKitFactory != null && !renderKitFactory.isEmpty();
-			case FacesConfigPackage.FACTORY_TYPE__VISIT_CONTEXT_FACTORY:
-				return visitContextFactory != null && !visitContextFactory.isEmpty();
-			case FacesConfigPackage.FACTORY_TYPE__FACTORY_EXTENSION:
-				return factoryExtension != null && !factoryExtension.isEmpty();
-			case FacesConfigPackage.FACTORY_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //FactoryTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FromActionTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FromActionTypeImpl.java
deleted file mode 100644
index 92c0eca..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FromActionTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FromActionType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>From Action Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FromActionTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FromActionTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class FromActionTypeImpl extends EObjectImpl implements FromActionType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected FromActionTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.FROM_ACTION_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.FROM_ACTION_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.FROM_ACTION_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.FROM_ACTION_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.FROM_ACTION_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.FROM_ACTION_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.FROM_ACTION_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.FROM_ACTION_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.FROM_ACTION_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.FROM_ACTION_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.FROM_ACTION_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //FromActionTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FromOutcomeTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FromOutcomeTypeImpl.java
deleted file mode 100644
index 85ebefb..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FromOutcomeTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FromOutcomeType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>From Outcome Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FromOutcomeTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FromOutcomeTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class FromOutcomeTypeImpl extends EObjectImpl implements FromOutcomeType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected FromOutcomeTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.FROM_OUTCOME_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.FROM_OUTCOME_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.FROM_OUTCOME_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.FROM_OUTCOME_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.FROM_OUTCOME_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.FROM_OUTCOME_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.FROM_OUTCOME_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.FROM_OUTCOME_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.FROM_OUTCOME_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.FROM_OUTCOME_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.FROM_OUTCOME_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //FromOutcomeTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FromViewIdTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FromViewIdTypeImpl.java
deleted file mode 100644
index 6205448..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/FromViewIdTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FromViewIdType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>From View Id Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FromViewIdTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.FromViewIdTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class FromViewIdTypeImpl extends EObjectImpl implements FromViewIdType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected FromViewIdTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.FROM_VIEW_ID_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.FROM_VIEW_ID_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.FROM_VIEW_ID_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.FROM_VIEW_ID_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.FROM_VIEW_ID_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.FROM_VIEW_ID_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.FROM_VIEW_ID_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.FROM_VIEW_ID_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.FROM_VIEW_ID_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.FROM_VIEW_ID_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.FROM_VIEW_ID_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //FromViewIdTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/IconTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/IconTypeImpl.java
deleted file mode 100644
index c567901..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/IconTypeImpl.java
+++ /dev/null
@@ -1,378 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.IconType;
-import org.eclipse.jst.jsf.facesconfig.emf.LargeIconType;
-import org.eclipse.jst.jsf.facesconfig.emf.SmallIconType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Icon Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.IconTypeImpl#getSmallIcon <em>Small Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.IconTypeImpl#getLargeIcon <em>Large Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.IconTypeImpl#getLang <em>Lang</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.IconTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class IconTypeImpl extends EObjectImpl implements IconType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getSmallIcon() <em>Small Icon</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getSmallIcon()
-	 * @generated
-	 * @ordered
-	 */
-	protected SmallIconType smallIcon;
-
-    /**
-	 * The cached value of the '{@link #getLargeIcon() <em>Large Icon</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getLargeIcon()
-	 * @generated
-	 * @ordered
-	 */
-	protected LargeIconType largeIcon;
-
-    /**
-	 * The default value of the '{@link #getLang() <em>Lang</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getLang()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String LANG_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getLang() <em>Lang</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getLang()
-	 * @generated
-	 * @ordered
-	 */
-	protected String lang = LANG_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected IconTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.ICON_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SmallIconType getSmallIcon() {
-		return smallIcon;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newSmallIcon 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetSmallIcon(SmallIconType newSmallIcon, NotificationChain msgs) {
-		SmallIconType oldSmallIcon = smallIcon;
-		smallIcon = newSmallIcon;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ICON_TYPE__SMALL_ICON, oldSmallIcon, newSmallIcon);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setSmallIcon(SmallIconType newSmallIcon) {
-		if (newSmallIcon != smallIcon) {
-			NotificationChain msgs = null;
-			if (smallIcon != null)
-				msgs = ((InternalEObject)smallIcon).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.ICON_TYPE__SMALL_ICON, null, msgs);
-			if (newSmallIcon != null)
-				msgs = ((InternalEObject)newSmallIcon).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.ICON_TYPE__SMALL_ICON, null, msgs);
-			msgs = basicSetSmallIcon(newSmallIcon, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ICON_TYPE__SMALL_ICON, newSmallIcon, newSmallIcon));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public LargeIconType getLargeIcon() {
-		return largeIcon;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newLargeIcon 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetLargeIcon(LargeIconType newLargeIcon, NotificationChain msgs) {
-		LargeIconType oldLargeIcon = largeIcon;
-		largeIcon = newLargeIcon;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ICON_TYPE__LARGE_ICON, oldLargeIcon, newLargeIcon);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setLargeIcon(LargeIconType newLargeIcon) {
-		if (newLargeIcon != largeIcon) {
-			NotificationChain msgs = null;
-			if (largeIcon != null)
-				msgs = ((InternalEObject)largeIcon).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.ICON_TYPE__LARGE_ICON, null, msgs);
-			if (newLargeIcon != null)
-				msgs = ((InternalEObject)newLargeIcon).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.ICON_TYPE__LARGE_ICON, null, msgs);
-			msgs = basicSetLargeIcon(newLargeIcon, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ICON_TYPE__LARGE_ICON, newLargeIcon, newLargeIcon));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getLang() {
-		return lang;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setLang(String newLang) {
-		String oldLang = lang;
-		lang = newLang;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ICON_TYPE__LANG, oldLang, lang));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ICON_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.ICON_TYPE__SMALL_ICON:
-				return basicSetSmallIcon(null, msgs);
-			case FacesConfigPackage.ICON_TYPE__LARGE_ICON:
-				return basicSetLargeIcon(null, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.ICON_TYPE__SMALL_ICON:
-				return getSmallIcon();
-			case FacesConfigPackage.ICON_TYPE__LARGE_ICON:
-				return getLargeIcon();
-			case FacesConfigPackage.ICON_TYPE__LANG:
-				return getLang();
-			case FacesConfigPackage.ICON_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.ICON_TYPE__SMALL_ICON:
-				setSmallIcon((SmallIconType)newValue);
-				return;
-			case FacesConfigPackage.ICON_TYPE__LARGE_ICON:
-				setLargeIcon((LargeIconType)newValue);
-				return;
-			case FacesConfigPackage.ICON_TYPE__LANG:
-				setLang((String)newValue);
-				return;
-			case FacesConfigPackage.ICON_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.ICON_TYPE__SMALL_ICON:
-				setSmallIcon((SmallIconType)null);
-				return;
-			case FacesConfigPackage.ICON_TYPE__LARGE_ICON:
-				setLargeIcon((LargeIconType)null);
-				return;
-			case FacesConfigPackage.ICON_TYPE__LANG:
-				setLang(LANG_EDEFAULT);
-				return;
-			case FacesConfigPackage.ICON_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.ICON_TYPE__SMALL_ICON:
-				return smallIcon != null;
-			case FacesConfigPackage.ICON_TYPE__LARGE_ICON:
-				return largeIcon != null;
-			case FacesConfigPackage.ICON_TYPE__LANG:
-				return LANG_EDEFAULT == null ? lang != null : !LANG_EDEFAULT.equals(lang);
-			case FacesConfigPackage.ICON_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (lang: "); //$NON-NLS-1$
-		result.append(lang);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //IconTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/IfTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/IfTypeImpl.java
deleted file mode 100644
index 8615aa0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/IfTypeImpl.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.IfType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>If Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.IfTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.IfTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class IfTypeImpl extends EObjectImpl implements IfType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected IfTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.IF_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.IF_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.IF_TYPE__ID, oldId, id));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.IF_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.IF_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.IF_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.IF_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.IF_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.IF_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.IF_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.IF_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //IfTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/KeyClassTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/KeyClassTypeImpl.java
deleted file mode 100644
index 943a8ef..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/KeyClassTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.KeyClassType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Key Class Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.KeyClassTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.KeyClassTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class KeyClassTypeImpl extends EObjectImpl implements KeyClassType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected KeyClassTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.KEY_CLASS_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.KEY_CLASS_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.KEY_CLASS_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.KEY_CLASS_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.KEY_CLASS_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.KEY_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.KEY_CLASS_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.KEY_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.KEY_CLASS_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.KEY_CLASS_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.KEY_CLASS_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //KeyClassTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/KeyTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/KeyTypeImpl.java
deleted file mode 100644
index 3a58b50..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/KeyTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.KeyType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Key Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.KeyTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.KeyTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class KeyTypeImpl extends EObjectImpl implements KeyType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected KeyTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.KEY_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.KEY_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.KEY_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.KEY_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.KEY_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.KEY_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.KEY_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.KEY_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.KEY_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.KEY_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.KEY_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //KeyTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/LargeIconTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/LargeIconTypeImpl.java
deleted file mode 100644
index 153fa49..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/LargeIconTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.LargeIconType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Large Icon Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LargeIconTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LargeIconTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class LargeIconTypeImpl extends EObjectImpl implements LargeIconType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected LargeIconTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.LARGE_ICON_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.LARGE_ICON_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.LARGE_ICON_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.LARGE_ICON_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.LARGE_ICON_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.LARGE_ICON_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.LARGE_ICON_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.LARGE_ICON_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.LARGE_ICON_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.LARGE_ICON_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.LARGE_ICON_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //LargeIconTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/LifecycleExtensionTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/LifecycleExtensionTypeImpl.java
deleted file mode 100644
index 19262a0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/LifecycleExtensionTypeImpl.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.LifecycleExtensionType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Lifecycle Extension Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * </p>
- *
- * @generated
- */
-public class LifecycleExtensionTypeImpl extends ExtensionTypeImpl implements LifecycleExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    @SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected LifecycleExtensionTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.LIFECYCLE_EXTENSION_TYPE;
-	}
-
-} //LifecycleExtensionTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/LifecycleFactoryTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/LifecycleFactoryTypeImpl.java
deleted file mode 100644
index 562c38c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/LifecycleFactoryTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.LifecycleFactoryType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Lifecycle Factory Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LifecycleFactoryTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LifecycleFactoryTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class LifecycleFactoryTypeImpl extends EObjectImpl implements LifecycleFactoryType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected LifecycleFactoryTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.LIFECYCLE_FACTORY_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.LIFECYCLE_FACTORY_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.LIFECYCLE_FACTORY_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.LIFECYCLE_FACTORY_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.LIFECYCLE_FACTORY_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.LIFECYCLE_FACTORY_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.LIFECYCLE_FACTORY_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.LIFECYCLE_FACTORY_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.LIFECYCLE_FACTORY_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.LIFECYCLE_FACTORY_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.LIFECYCLE_FACTORY_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //LifecycleFactoryTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/LifecycleTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/LifecycleTypeImpl.java
deleted file mode 100644
index a01a5f6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/LifecycleTypeImpl.java
+++ /dev/null
@@ -1,263 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.LifecycleExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.LifecycleType;
-import org.eclipse.jst.jsf.facesconfig.emf.PhaseListenerType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Lifecycle Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LifecycleTypeImpl#getPhaseListener <em>Phase Listener</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LifecycleTypeImpl#getLifecycleExtension <em>Lifecycle Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LifecycleTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class LifecycleTypeImpl extends EObjectImpl implements LifecycleType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getPhaseListener() <em>Phase Listener</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getPhaseListener()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList phaseListener;
-
-    /**
-	 * The cached value of the '{@link #getLifecycleExtension() <em>Lifecycle Extension</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getLifecycleExtension()
-	 * @generated
-	 * @ordered
-	 */
-    protected EList lifecycleExtension;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected LifecycleTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.LIFECYCLE_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getPhaseListener() {
-		if (phaseListener == null) {
-			phaseListener = new EObjectContainmentEList(PhaseListenerType.class, this, FacesConfigPackage.LIFECYCLE_TYPE__PHASE_LISTENER);
-		}
-		return phaseListener;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EList getLifecycleExtension() {
-		if (lifecycleExtension == null) {
-			lifecycleExtension = new EObjectContainmentEList(LifecycleExtensionType.class, this, FacesConfigPackage.LIFECYCLE_TYPE__LIFECYCLE_EXTENSION);
-		}
-		return lifecycleExtension;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.LIFECYCLE_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.LIFECYCLE_TYPE__PHASE_LISTENER:
-				return ((InternalEList)getPhaseListener()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.LIFECYCLE_TYPE__LIFECYCLE_EXTENSION:
-				return ((InternalEList)getLifecycleExtension()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.LIFECYCLE_TYPE__PHASE_LISTENER:
-				return getPhaseListener();
-			case FacesConfigPackage.LIFECYCLE_TYPE__LIFECYCLE_EXTENSION:
-				return getLifecycleExtension();
-			case FacesConfigPackage.LIFECYCLE_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.LIFECYCLE_TYPE__PHASE_LISTENER:
-				getPhaseListener().clear();
-				getPhaseListener().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.LIFECYCLE_TYPE__LIFECYCLE_EXTENSION:
-				getLifecycleExtension().clear();
-				getLifecycleExtension().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.LIFECYCLE_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.LIFECYCLE_TYPE__PHASE_LISTENER:
-				getPhaseListener().clear();
-				return;
-			case FacesConfigPackage.LIFECYCLE_TYPE__LIFECYCLE_EXTENSION:
-				getLifecycleExtension().clear();
-				return;
-			case FacesConfigPackage.LIFECYCLE_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.LIFECYCLE_TYPE__PHASE_LISTENER:
-				return phaseListener != null && !phaseListener.isEmpty();
-			case FacesConfigPackage.LIFECYCLE_TYPE__LIFECYCLE_EXTENSION:
-				return lifecycleExtension != null && !lifecycleExtension.isEmpty();
-			case FacesConfigPackage.LIFECYCLE_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //LifecycleTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ListEntriesTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ListEntriesTypeImpl.java
deleted file mode 100644
index fd40f96..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ListEntriesTypeImpl.java
+++ /dev/null
@@ -1,333 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType;
-import org.eclipse.jst.jsf.facesconfig.emf.NullValueType;
-import org.eclipse.jst.jsf.facesconfig.emf.ValueClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.ValueType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>List Entries Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ListEntriesTypeImpl#getValueClass <em>Value Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ListEntriesTypeImpl#getNullValue <em>Null Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ListEntriesTypeImpl#getValue <em>Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ListEntriesTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ListEntriesTypeImpl extends EObjectImpl implements ListEntriesType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getValueClass() <em>Value Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getValueClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected ValueClassType valueClass;
-
-    /**
-	 * The cached value of the '{@link #getNullValue() <em>Null Value</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getNullValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList nullValue;
-
-    /**
-	 * The cached value of the '{@link #getValue() <em>Value</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList value;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ListEntriesTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.LIST_ENTRIES_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValueClassType getValueClass() {
-		return valueClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newValueClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetValueClass(ValueClassType newValueClass, NotificationChain msgs) {
-		ValueClassType oldValueClass = valueClass;
-		valueClass = newValueClass;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.LIST_ENTRIES_TYPE__VALUE_CLASS, oldValueClass, newValueClass);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setValueClass(ValueClassType newValueClass) {
-		if (newValueClass != valueClass) {
-			NotificationChain msgs = null;
-			if (valueClass != null)
-				msgs = ((InternalEObject)valueClass).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.LIST_ENTRIES_TYPE__VALUE_CLASS, null, msgs);
-			if (newValueClass != null)
-				msgs = ((InternalEObject)newValueClass).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.LIST_ENTRIES_TYPE__VALUE_CLASS, null, msgs);
-			msgs = basicSetValueClass(newValueClass, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.LIST_ENTRIES_TYPE__VALUE_CLASS, newValueClass, newValueClass));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getNullValue() {
-		if (nullValue == null) {
-			nullValue = new EObjectContainmentEList(NullValueType.class, this, FacesConfigPackage.LIST_ENTRIES_TYPE__NULL_VALUE);
-		}
-		return nullValue;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getValue() {
-		if (value == null) {
-			value = new EObjectContainmentEList(ValueType.class, this, FacesConfigPackage.LIST_ENTRIES_TYPE__VALUE);
-		}
-		return value;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.LIST_ENTRIES_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__VALUE_CLASS:
-				return basicSetValueClass(null, msgs);
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__NULL_VALUE:
-				return ((InternalEList)getNullValue()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__VALUE:
-				return ((InternalEList)getValue()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__VALUE_CLASS:
-				return getValueClass();
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__NULL_VALUE:
-				return getNullValue();
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__VALUE:
-				return getValue();
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__VALUE_CLASS:
-				setValueClass((ValueClassType)newValue);
-				return;
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__NULL_VALUE:
-				getNullValue().clear();
-				getNullValue().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__VALUE:
-				getValue().clear();
-				getValue().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__VALUE_CLASS:
-				setValueClass((ValueClassType)null);
-				return;
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__NULL_VALUE:
-				getNullValue().clear();
-				return;
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__VALUE:
-				getValue().clear();
-				return;
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__VALUE_CLASS:
-				return valueClass != null;
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__NULL_VALUE:
-				return nullValue != null && !nullValue.isEmpty();
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__VALUE:
-				return value != null && !value.isEmpty();
-			case FacesConfigPackage.LIST_ENTRIES_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ListEntriesTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/LocaleConfigTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/LocaleConfigTypeImpl.java
deleted file mode 100644
index 9f17d16..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/LocaleConfigTypeImpl.java
+++ /dev/null
@@ -1,296 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.DefaultLocaleType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType;
-import org.eclipse.jst.jsf.facesconfig.emf.SupportedLocaleType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Locale Config Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LocaleConfigTypeImpl#getDefaultLocale <em>Default Locale</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LocaleConfigTypeImpl#getSupportedLocale <em>Supported Locale</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.LocaleConfigTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class LocaleConfigTypeImpl extends EObjectImpl implements LocaleConfigType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getDefaultLocale() <em>Default Locale</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDefaultLocale()
-	 * @generated
-	 * @ordered
-	 */
-	protected DefaultLocaleType defaultLocale;
-
-    /**
-	 * The cached value of the '{@link #getSupportedLocale() <em>Supported Locale</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getSupportedLocale()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList supportedLocale;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected LocaleConfigTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.LOCALE_CONFIG_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DefaultLocaleType getDefaultLocale() {
-		return defaultLocale;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newDefaultLocale 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetDefaultLocale(DefaultLocaleType newDefaultLocale, NotificationChain msgs) {
-		DefaultLocaleType oldDefaultLocale = defaultLocale;
-		defaultLocale = newDefaultLocale;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.LOCALE_CONFIG_TYPE__DEFAULT_LOCALE, oldDefaultLocale, newDefaultLocale);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setDefaultLocale(DefaultLocaleType newDefaultLocale) {
-		if (newDefaultLocale != defaultLocale) {
-			NotificationChain msgs = null;
-			if (defaultLocale != null)
-				msgs = ((InternalEObject)defaultLocale).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.LOCALE_CONFIG_TYPE__DEFAULT_LOCALE, null, msgs);
-			if (newDefaultLocale != null)
-				msgs = ((InternalEObject)newDefaultLocale).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.LOCALE_CONFIG_TYPE__DEFAULT_LOCALE, null, msgs);
-			msgs = basicSetDefaultLocale(newDefaultLocale, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.LOCALE_CONFIG_TYPE__DEFAULT_LOCALE, newDefaultLocale, newDefaultLocale));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getSupportedLocale() {
-		if (supportedLocale == null) {
-			supportedLocale = new EObjectContainmentEList(SupportedLocaleType.class, this, FacesConfigPackage.LOCALE_CONFIG_TYPE__SUPPORTED_LOCALE);
-		}
-		return supportedLocale;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.LOCALE_CONFIG_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.LOCALE_CONFIG_TYPE__DEFAULT_LOCALE:
-				return basicSetDefaultLocale(null, msgs);
-			case FacesConfigPackage.LOCALE_CONFIG_TYPE__SUPPORTED_LOCALE:
-				return ((InternalEList)getSupportedLocale()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.LOCALE_CONFIG_TYPE__DEFAULT_LOCALE:
-				return getDefaultLocale();
-			case FacesConfigPackage.LOCALE_CONFIG_TYPE__SUPPORTED_LOCALE:
-				return getSupportedLocale();
-			case FacesConfigPackage.LOCALE_CONFIG_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.LOCALE_CONFIG_TYPE__DEFAULT_LOCALE:
-				setDefaultLocale((DefaultLocaleType)newValue);
-				return;
-			case FacesConfigPackage.LOCALE_CONFIG_TYPE__SUPPORTED_LOCALE:
-				getSupportedLocale().clear();
-				getSupportedLocale().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.LOCALE_CONFIG_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.LOCALE_CONFIG_TYPE__DEFAULT_LOCALE:
-				setDefaultLocale((DefaultLocaleType)null);
-				return;
-			case FacesConfigPackage.LOCALE_CONFIG_TYPE__SUPPORTED_LOCALE:
-				getSupportedLocale().clear();
-				return;
-			case FacesConfigPackage.LOCALE_CONFIG_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.LOCALE_CONFIG_TYPE__DEFAULT_LOCALE:
-				return defaultLocale != null;
-			case FacesConfigPackage.LOCALE_CONFIG_TYPE__SUPPORTED_LOCALE:
-				return supportedLocale != null && !supportedLocale.isEmpty();
-			case FacesConfigPackage.LOCALE_CONFIG_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //LocaleConfigTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ManagedBeanClassTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ManagedBeanClassTypeImpl.java
deleted file mode 100644
index 0e48234..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ManagedBeanClassTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanClassType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Managed Bean Class Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanClassTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanClassTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ManagedBeanClassTypeImpl extends EObjectImpl implements ManagedBeanClassType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ManagedBeanClassTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.MANAGED_BEAN_CLASS_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_BEAN_CLASS_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_BEAN_CLASS_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_BEAN_CLASS_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.MANAGED_BEAN_CLASS_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_BEAN_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_CLASS_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_BEAN_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_CLASS_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_BEAN_CLASS_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.MANAGED_BEAN_CLASS_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ManagedBeanClassTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ManagedBeanExtensionTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ManagedBeanExtensionTypeImpl.java
deleted file mode 100644
index e8f3be1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ManagedBeanExtensionTypeImpl.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanExtensionType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Managed Bean Extension Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * </p>
- *
- * @generated
- */
-public class ManagedBeanExtensionTypeImpl extends ExtensionTypeImpl implements ManagedBeanExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    @SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected ManagedBeanExtensionTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.MANAGED_BEAN_EXTENSION_TYPE;
-	}
-
-} //ManagedBeanExtensionTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ManagedBeanNameTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ManagedBeanNameTypeImpl.java
deleted file mode 100644
index 202ab74..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ManagedBeanNameTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanNameType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Managed Bean Name Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanNameTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanNameTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ManagedBeanNameTypeImpl extends EObjectImpl implements ManagedBeanNameType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ManagedBeanNameTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.MANAGED_BEAN_NAME_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_BEAN_NAME_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_BEAN_NAME_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_BEAN_NAME_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.MANAGED_BEAN_NAME_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_BEAN_NAME_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_NAME_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_BEAN_NAME_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_NAME_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_BEAN_NAME_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.MANAGED_BEAN_NAME_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ManagedBeanNameTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ManagedBeanScopeTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ManagedBeanScopeTypeImpl.java
deleted file mode 100644
index 3091a77..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ManagedBeanScopeTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanScopeType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Managed Bean Scope Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanScopeTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanScopeTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ManagedBeanScopeTypeImpl extends EObjectImpl implements ManagedBeanScopeType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ManagedBeanScopeTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.MANAGED_BEAN_SCOPE_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_BEAN_SCOPE_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_BEAN_SCOPE_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_BEAN_SCOPE_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.MANAGED_BEAN_SCOPE_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_BEAN_SCOPE_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_SCOPE_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_BEAN_SCOPE_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_SCOPE_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_BEAN_SCOPE_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.MANAGED_BEAN_SCOPE_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ManagedBeanScopeTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ManagedBeanTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ManagedBeanTypeImpl.java
deleted file mode 100644
index 4a21aa8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ManagedBeanTypeImpl.java
+++ /dev/null
@@ -1,778 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.DescriptionType;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.IconType;
-import org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType;
-import org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanScopeType;
-import org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType;
-import org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType;
-import org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Managed Bean Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanTypeImpl#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanTypeImpl#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanTypeImpl#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanTypeImpl#getManagedBeanName <em>Managed Bean Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanTypeImpl#getManagedBeanClass <em>Managed Bean Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanTypeImpl#getManagedBeanScope <em>Managed Bean Scope</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanTypeImpl#getManagedProperty <em>Managed Property</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanTypeImpl#getMapEntries <em>Map Entries</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanTypeImpl#getListEntries <em>List Entries</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanTypeImpl#getManagedBeanExtension <em>Managed Bean Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanTypeImpl#getId <em>Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedBeanTypeImpl#isEager <em>Eager</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ManagedBeanTypeImpl extends EObjectImpl implements ManagedBeanType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getDescription() <em>Description</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDescription()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList description;
-
-    /**
-	 * The cached value of the '{@link #getDisplayName() <em>Display Name</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDisplayName()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList displayName;
-
-    /**
-	 * The cached value of the '{@link #getIcon() <em>Icon</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getIcon()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList icon;
-
-    /**
-	 * The cached value of the '{@link #getManagedBeanName() <em>Managed Bean Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getManagedBeanName()
-	 * @generated
-	 * @ordered
-	 */
-	protected ManagedBeanNameType managedBeanName;
-
-    /**
-	 * The cached value of the '{@link #getManagedBeanClass() <em>Managed Bean Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getManagedBeanClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected ManagedBeanClassType managedBeanClass;
-
-    /**
-	 * The cached value of the '{@link #getManagedBeanScope() <em>Managed Bean Scope</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getManagedBeanScope()
-	 * @generated
-	 * @ordered
-	 */
-	protected ManagedBeanScopeType managedBeanScope;
-
-    /**
-	 * The cached value of the '{@link #getManagedProperty() <em>Managed Property</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getManagedProperty()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList managedProperty;
-
-    /**
-	 * The cached value of the '{@link #getMapEntries() <em>Map Entries</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getMapEntries()
-	 * @generated
-	 * @ordered
-	 */
-	protected MapEntriesType mapEntries;
-
-    /**
-	 * The cached value of the '{@link #getListEntries() <em>List Entries</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getListEntries()
-	 * @generated
-	 * @ordered
-	 */
-	protected ListEntriesType listEntries;
-
-    /**
-	 * The cached value of the '{@link #getManagedBeanExtension() <em>Managed Bean Extension</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getManagedBeanExtension()
-	 * @generated
-	 * @ordered
-	 */
-    protected EList managedBeanExtension;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #isEager() <em>Eager</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isEager()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean EAGER_EDEFAULT = false;
-
-				/**
-	 * The cached value of the '{@link #isEager() <em>Eager</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isEager()
-	 * @generated
-	 * @ordered
-	 */
-	protected boolean eager = EAGER_EDEFAULT;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ManagedBeanTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.MANAGED_BEAN_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDescription() {
-		if (description == null) {
-			description = new EObjectContainmentEList(DescriptionType.class, this, FacesConfigPackage.MANAGED_BEAN_TYPE__DESCRIPTION);
-		}
-		return description;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDisplayName() {
-		if (displayName == null) {
-			displayName = new EObjectContainmentEList(DisplayNameType.class, this, FacesConfigPackage.MANAGED_BEAN_TYPE__DISPLAY_NAME);
-		}
-		return displayName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getIcon() {
-		if (icon == null) {
-			icon = new EObjectContainmentEList(IconType.class, this, FacesConfigPackage.MANAGED_BEAN_TYPE__ICON);
-		}
-		return icon;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ManagedBeanNameType getManagedBeanName() {
-		return managedBeanName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newManagedBeanName 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetManagedBeanName(ManagedBeanNameType newManagedBeanName, NotificationChain msgs) {
-		ManagedBeanNameType oldManagedBeanName = managedBeanName;
-		managedBeanName = newManagedBeanName;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_NAME, oldManagedBeanName, newManagedBeanName);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setManagedBeanName(ManagedBeanNameType newManagedBeanName) {
-		if (newManagedBeanName != managedBeanName) {
-			NotificationChain msgs = null;
-			if (managedBeanName != null)
-				msgs = ((InternalEObject)managedBeanName).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_NAME, null, msgs);
-			if (newManagedBeanName != null)
-				msgs = ((InternalEObject)newManagedBeanName).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_NAME, null, msgs);
-			msgs = basicSetManagedBeanName(newManagedBeanName, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_NAME, newManagedBeanName, newManagedBeanName));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ManagedBeanClassType getManagedBeanClass() {
-		return managedBeanClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newManagedBeanClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetManagedBeanClass(ManagedBeanClassType newManagedBeanClass, NotificationChain msgs) {
-		ManagedBeanClassType oldManagedBeanClass = managedBeanClass;
-		managedBeanClass = newManagedBeanClass;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_CLASS, oldManagedBeanClass, newManagedBeanClass);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setManagedBeanClass(ManagedBeanClassType newManagedBeanClass) {
-		if (newManagedBeanClass != managedBeanClass) {
-			NotificationChain msgs = null;
-			if (managedBeanClass != null)
-				msgs = ((InternalEObject)managedBeanClass).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_CLASS, null, msgs);
-			if (newManagedBeanClass != null)
-				msgs = ((InternalEObject)newManagedBeanClass).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_CLASS, null, msgs);
-			msgs = basicSetManagedBeanClass(newManagedBeanClass, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_CLASS, newManagedBeanClass, newManagedBeanClass));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ManagedBeanScopeType getManagedBeanScope() {
-		return managedBeanScope;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newManagedBeanScope 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetManagedBeanScope(ManagedBeanScopeType newManagedBeanScope, NotificationChain msgs) {
-		ManagedBeanScopeType oldManagedBeanScope = managedBeanScope;
-		managedBeanScope = newManagedBeanScope;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_SCOPE, oldManagedBeanScope, newManagedBeanScope);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setManagedBeanScope(ManagedBeanScopeType newManagedBeanScope) {
-		if (newManagedBeanScope != managedBeanScope) {
-			NotificationChain msgs = null;
-			if (managedBeanScope != null)
-				msgs = ((InternalEObject)managedBeanScope).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_SCOPE, null, msgs);
-			if (newManagedBeanScope != null)
-				msgs = ((InternalEObject)newManagedBeanScope).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_SCOPE, null, msgs);
-			msgs = basicSetManagedBeanScope(newManagedBeanScope, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_SCOPE, newManagedBeanScope, newManagedBeanScope));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getManagedProperty() {
-		if (managedProperty == null) {
-			managedProperty = new EObjectContainmentEList(ManagedPropertyType.class, this, FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_PROPERTY);
-		}
-		return managedProperty;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public MapEntriesType getMapEntries() {
-		return mapEntries;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newMapEntries 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetMapEntries(MapEntriesType newMapEntries, NotificationChain msgs) {
-		MapEntriesType oldMapEntries = mapEntries;
-		mapEntries = newMapEntries;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_BEAN_TYPE__MAP_ENTRIES, oldMapEntries, newMapEntries);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setMapEntries(MapEntriesType newMapEntries) {
-		if (newMapEntries != mapEntries) {
-			NotificationChain msgs = null;
-			if (mapEntries != null)
-				msgs = ((InternalEObject)mapEntries).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_BEAN_TYPE__MAP_ENTRIES, null, msgs);
-			if (newMapEntries != null)
-				msgs = ((InternalEObject)newMapEntries).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_BEAN_TYPE__MAP_ENTRIES, null, msgs);
-			msgs = basicSetMapEntries(newMapEntries, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_BEAN_TYPE__MAP_ENTRIES, newMapEntries, newMapEntries));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ListEntriesType getListEntries() {
-		return listEntries;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newListEntries 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetListEntries(ListEntriesType newListEntries, NotificationChain msgs) {
-		ListEntriesType oldListEntries = listEntries;
-		listEntries = newListEntries;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_BEAN_TYPE__LIST_ENTRIES, oldListEntries, newListEntries);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setListEntries(ListEntriesType newListEntries) {
-		if (newListEntries != listEntries) {
-			NotificationChain msgs = null;
-			if (listEntries != null)
-				msgs = ((InternalEObject)listEntries).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_BEAN_TYPE__LIST_ENTRIES, null, msgs);
-			if (newListEntries != null)
-				msgs = ((InternalEObject)newListEntries).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_BEAN_TYPE__LIST_ENTRIES, null, msgs);
-			msgs = basicSetListEntries(newListEntries, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_BEAN_TYPE__LIST_ENTRIES, newListEntries, newListEntries));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EList getManagedBeanExtension() {
-		if (managedBeanExtension == null) {
-			managedBeanExtension = new EObjectContainmentEList(ManagedBeanExtensionType.class, this, FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_EXTENSION);
-		}
-		return managedBeanExtension;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_BEAN_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isEager() {
-		return eager;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setEager(boolean newEager) {
-		boolean oldEager = eager;
-		eager = newEager;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_BEAN_TYPE__EAGER, oldEager, eager));
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__DESCRIPTION:
-				return ((InternalEList)getDescription()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__DISPLAY_NAME:
-				return ((InternalEList)getDisplayName()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__ICON:
-				return ((InternalEList)getIcon()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_NAME:
-				return basicSetManagedBeanName(null, msgs);
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_CLASS:
-				return basicSetManagedBeanClass(null, msgs);
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_SCOPE:
-				return basicSetManagedBeanScope(null, msgs);
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_PROPERTY:
-				return ((InternalEList)getManagedProperty()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MAP_ENTRIES:
-				return basicSetMapEntries(null, msgs);
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__LIST_ENTRIES:
-				return basicSetListEntries(null, msgs);
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_EXTENSION:
-				return ((InternalEList)getManagedBeanExtension()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__DESCRIPTION:
-				return getDescription();
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__DISPLAY_NAME:
-				return getDisplayName();
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__ICON:
-				return getIcon();
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_NAME:
-				return getManagedBeanName();
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_CLASS:
-				return getManagedBeanClass();
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_SCOPE:
-				return getManagedBeanScope();
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_PROPERTY:
-				return getManagedProperty();
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MAP_ENTRIES:
-				return getMapEntries();
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__LIST_ENTRIES:
-				return getListEntries();
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_EXTENSION:
-				return getManagedBeanExtension();
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__ID:
-				return getId();
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__EAGER:
-				return isEager() ? Boolean.TRUE : Boolean.FALSE;
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__DESCRIPTION:
-				getDescription().clear();
-				getDescription().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				getDisplayName().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__ICON:
-				getIcon().clear();
-				getIcon().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_NAME:
-				setManagedBeanName((ManagedBeanNameType)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_CLASS:
-				setManagedBeanClass((ManagedBeanClassType)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_SCOPE:
-				setManagedBeanScope((ManagedBeanScopeType)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_PROPERTY:
-				getManagedProperty().clear();
-				getManagedProperty().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MAP_ENTRIES:
-				setMapEntries((MapEntriesType)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__LIST_ENTRIES:
-				setListEntries((ListEntriesType)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_EXTENSION:
-				getManagedBeanExtension().clear();
-				getManagedBeanExtension().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__ID:
-				setId((String)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__EAGER:
-				setEager(((Boolean)newValue).booleanValue());
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__DESCRIPTION:
-				getDescription().clear();
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__ICON:
-				getIcon().clear();
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_NAME:
-				setManagedBeanName((ManagedBeanNameType)null);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_CLASS:
-				setManagedBeanClass((ManagedBeanClassType)null);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_SCOPE:
-				setManagedBeanScope((ManagedBeanScopeType)null);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_PROPERTY:
-				getManagedProperty().clear();
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MAP_ENTRIES:
-				setMapEntries((MapEntriesType)null);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__LIST_ENTRIES:
-				setListEntries((ListEntriesType)null);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_EXTENSION:
-				getManagedBeanExtension().clear();
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__EAGER:
-				setEager(EAGER_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__DESCRIPTION:
-				return description != null && !description.isEmpty();
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__DISPLAY_NAME:
-				return displayName != null && !displayName.isEmpty();
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__ICON:
-				return icon != null && !icon.isEmpty();
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_NAME:
-				return managedBeanName != null;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_CLASS:
-				return managedBeanClass != null;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_SCOPE:
-				return managedBeanScope != null;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_PROPERTY:
-				return managedProperty != null && !managedProperty.isEmpty();
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MAP_ENTRIES:
-				return mapEntries != null;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__LIST_ENTRIES:
-				return listEntries != null;
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__MANAGED_BEAN_EXTENSION:
-				return managedBeanExtension != null && !managedBeanExtension.isEmpty();
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-			case FacesConfigPackage.MANAGED_BEAN_TYPE__EAGER:
-				return eager != EAGER_EDEFAULT;
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(", eager: "); //$NON-NLS-1$
-		result.append(eager);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ManagedBeanTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ManagedPropertyTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ManagedPropertyTypeImpl.java
deleted file mode 100644
index 979e640..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ManagedPropertyTypeImpl.java
+++ /dev/null
@@ -1,720 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.DescriptionType;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.IconType;
-import org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType;
-import org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType;
-import org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType;
-import org.eclipse.jst.jsf.facesconfig.emf.NullValueType;
-import org.eclipse.jst.jsf.facesconfig.emf.PropertyClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.PropertyNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.ValueType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Managed Property Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedPropertyTypeImpl#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedPropertyTypeImpl#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedPropertyTypeImpl#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedPropertyTypeImpl#getPropertyName <em>Property Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedPropertyTypeImpl#getPropertyClass <em>Property Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedPropertyTypeImpl#getMapEntries <em>Map Entries</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedPropertyTypeImpl#getNullValue <em>Null Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedPropertyTypeImpl#getValue <em>Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedPropertyTypeImpl#getListEntries <em>List Entries</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ManagedPropertyTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ManagedPropertyTypeImpl extends EObjectImpl implements ManagedPropertyType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getDescription() <em>Description</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDescription()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList description;
-
-    /**
-	 * The cached value of the '{@link #getDisplayName() <em>Display Name</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDisplayName()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList displayName;
-
-    /**
-	 * The cached value of the '{@link #getIcon() <em>Icon</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getIcon()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList icon;
-
-    /**
-	 * The cached value of the '{@link #getPropertyName() <em>Property Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getPropertyName()
-	 * @generated
-	 * @ordered
-	 */
-	protected PropertyNameType propertyName;
-
-    /**
-	 * The cached value of the '{@link #getPropertyClass() <em>Property Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getPropertyClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected PropertyClassType propertyClass;
-
-    /**
-	 * The cached value of the '{@link #getMapEntries() <em>Map Entries</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getMapEntries()
-	 * @generated
-	 * @ordered
-	 */
-	protected MapEntriesType mapEntries;
-
-    /**
-	 * The cached value of the '{@link #getNullValue() <em>Null Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getNullValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected NullValueType nullValue;
-
-    /**
-	 * The cached value of the '{@link #getValue() <em>Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected ValueType value;
-
-    /**
-	 * The cached value of the '{@link #getListEntries() <em>List Entries</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getListEntries()
-	 * @generated
-	 * @ordered
-	 */
-	protected ListEntriesType listEntries;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ManagedPropertyTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.MANAGED_PROPERTY_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDescription() {
-		if (description == null) {
-			description = new EObjectContainmentEList(DescriptionType.class, this, FacesConfigPackage.MANAGED_PROPERTY_TYPE__DESCRIPTION);
-		}
-		return description;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDisplayName() {
-		if (displayName == null) {
-			displayName = new EObjectContainmentEList(DisplayNameType.class, this, FacesConfigPackage.MANAGED_PROPERTY_TYPE__DISPLAY_NAME);
-		}
-		return displayName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getIcon() {
-		if (icon == null) {
-			icon = new EObjectContainmentEList(IconType.class, this, FacesConfigPackage.MANAGED_PROPERTY_TYPE__ICON);
-		}
-		return icon;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PropertyNameType getPropertyName() {
-		return propertyName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newPropertyName 
-     * @param msgs 
-     * @return  the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetPropertyName(PropertyNameType newPropertyName, NotificationChain msgs) {
-		PropertyNameType oldPropertyName = propertyName;
-		propertyName = newPropertyName;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_PROPERTY_TYPE__PROPERTY_NAME, oldPropertyName, newPropertyName);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setPropertyName(PropertyNameType newPropertyName) {
-		if (newPropertyName != propertyName) {
-			NotificationChain msgs = null;
-			if (propertyName != null)
-				msgs = ((InternalEObject)propertyName).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_PROPERTY_TYPE__PROPERTY_NAME, null, msgs);
-			if (newPropertyName != null)
-				msgs = ((InternalEObject)newPropertyName).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_PROPERTY_TYPE__PROPERTY_NAME, null, msgs);
-			msgs = basicSetPropertyName(newPropertyName, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_PROPERTY_TYPE__PROPERTY_NAME, newPropertyName, newPropertyName));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PropertyClassType getPropertyClass() {
-		return propertyClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newPropertyClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetPropertyClass(PropertyClassType newPropertyClass, NotificationChain msgs) {
-		PropertyClassType oldPropertyClass = propertyClass;
-		propertyClass = newPropertyClass;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_PROPERTY_TYPE__PROPERTY_CLASS, oldPropertyClass, newPropertyClass);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setPropertyClass(PropertyClassType newPropertyClass) {
-		if (newPropertyClass != propertyClass) {
-			NotificationChain msgs = null;
-			if (propertyClass != null)
-				msgs = ((InternalEObject)propertyClass).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_PROPERTY_TYPE__PROPERTY_CLASS, null, msgs);
-			if (newPropertyClass != null)
-				msgs = ((InternalEObject)newPropertyClass).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_PROPERTY_TYPE__PROPERTY_CLASS, null, msgs);
-			msgs = basicSetPropertyClass(newPropertyClass, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_PROPERTY_TYPE__PROPERTY_CLASS, newPropertyClass, newPropertyClass));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public MapEntriesType getMapEntries() {
-		return mapEntries;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newMapEntries 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetMapEntries(MapEntriesType newMapEntries, NotificationChain msgs) {
-		MapEntriesType oldMapEntries = mapEntries;
-		mapEntries = newMapEntries;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_PROPERTY_TYPE__MAP_ENTRIES, oldMapEntries, newMapEntries);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setMapEntries(MapEntriesType newMapEntries) {
-		if (newMapEntries != mapEntries) {
-			NotificationChain msgs = null;
-			if (mapEntries != null)
-				msgs = ((InternalEObject)mapEntries).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_PROPERTY_TYPE__MAP_ENTRIES, null, msgs);
-			if (newMapEntries != null)
-				msgs = ((InternalEObject)newMapEntries).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_PROPERTY_TYPE__MAP_ENTRIES, null, msgs);
-			msgs = basicSetMapEntries(newMapEntries, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_PROPERTY_TYPE__MAP_ENTRIES, newMapEntries, newMapEntries));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NullValueType getNullValue() {
-		return nullValue;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newNullValue 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetNullValue(NullValueType newNullValue, NotificationChain msgs) {
-		NullValueType oldNullValue = nullValue;
-		nullValue = newNullValue;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_PROPERTY_TYPE__NULL_VALUE, oldNullValue, newNullValue);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setNullValue(NullValueType newNullValue) {
-		if (newNullValue != nullValue) {
-			NotificationChain msgs = null;
-			if (nullValue != null)
-				msgs = ((InternalEObject)nullValue).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_PROPERTY_TYPE__NULL_VALUE, null, msgs);
-			if (newNullValue != null)
-				msgs = ((InternalEObject)newNullValue).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_PROPERTY_TYPE__NULL_VALUE, null, msgs);
-			msgs = basicSetNullValue(newNullValue, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_PROPERTY_TYPE__NULL_VALUE, newNullValue, newNullValue));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValueType getValue() {
-		return value;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newValue 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetValue(ValueType newValue, NotificationChain msgs) {
-		ValueType oldValue = value;
-		value = newValue;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_PROPERTY_TYPE__VALUE, oldValue, newValue);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setValue(ValueType newValue) {
-		if (newValue != value) {
-			NotificationChain msgs = null;
-			if (value != null)
-				msgs = ((InternalEObject)value).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_PROPERTY_TYPE__VALUE, null, msgs);
-			if (newValue != null)
-				msgs = ((InternalEObject)newValue).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_PROPERTY_TYPE__VALUE, null, msgs);
-			msgs = basicSetValue(newValue, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_PROPERTY_TYPE__VALUE, newValue, newValue));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ListEntriesType getListEntries() {
-		return listEntries;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newListEntries 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetListEntries(ListEntriesType newListEntries, NotificationChain msgs) {
-		ListEntriesType oldListEntries = listEntries;
-		listEntries = newListEntries;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_PROPERTY_TYPE__LIST_ENTRIES, oldListEntries, newListEntries);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setListEntries(ListEntriesType newListEntries) {
-		if (newListEntries != listEntries) {
-			NotificationChain msgs = null;
-			if (listEntries != null)
-				msgs = ((InternalEObject)listEntries).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_PROPERTY_TYPE__LIST_ENTRIES, null, msgs);
-			if (newListEntries != null)
-				msgs = ((InternalEObject)newListEntries).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MANAGED_PROPERTY_TYPE__LIST_ENTRIES, null, msgs);
-			msgs = basicSetListEntries(newListEntries, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_PROPERTY_TYPE__LIST_ENTRIES, newListEntries, newListEntries));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MANAGED_PROPERTY_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__DESCRIPTION:
-				return ((InternalEList)getDescription()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__DISPLAY_NAME:
-				return ((InternalEList)getDisplayName()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__ICON:
-				return ((InternalEList)getIcon()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__PROPERTY_NAME:
-				return basicSetPropertyName(null, msgs);
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__PROPERTY_CLASS:
-				return basicSetPropertyClass(null, msgs);
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__MAP_ENTRIES:
-				return basicSetMapEntries(null, msgs);
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__NULL_VALUE:
-				return basicSetNullValue(null, msgs);
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__VALUE:
-				return basicSetValue(null, msgs);
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__LIST_ENTRIES:
-				return basicSetListEntries(null, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__DESCRIPTION:
-				return getDescription();
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__DISPLAY_NAME:
-				return getDisplayName();
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__ICON:
-				return getIcon();
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__PROPERTY_NAME:
-				return getPropertyName();
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__PROPERTY_CLASS:
-				return getPropertyClass();
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__MAP_ENTRIES:
-				return getMapEntries();
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__NULL_VALUE:
-				return getNullValue();
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__VALUE:
-				return getValue();
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__LIST_ENTRIES:
-				return getListEntries();
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__DESCRIPTION:
-				getDescription().clear();
-				getDescription().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				getDisplayName().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__ICON:
-				getIcon().clear();
-				getIcon().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__PROPERTY_NAME:
-				setPropertyName((PropertyNameType)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__PROPERTY_CLASS:
-				setPropertyClass((PropertyClassType)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__MAP_ENTRIES:
-				setMapEntries((MapEntriesType)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__NULL_VALUE:
-				setNullValue((NullValueType)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__VALUE:
-				setValue((ValueType)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__LIST_ENTRIES:
-				setListEntries((ListEntriesType)newValue);
-				return;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__DESCRIPTION:
-				getDescription().clear();
-				return;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				return;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__ICON:
-				getIcon().clear();
-				return;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__PROPERTY_NAME:
-				setPropertyName((PropertyNameType)null);
-				return;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__PROPERTY_CLASS:
-				setPropertyClass((PropertyClassType)null);
-				return;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__MAP_ENTRIES:
-				setMapEntries((MapEntriesType)null);
-				return;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__NULL_VALUE:
-				setNullValue((NullValueType)null);
-				return;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__VALUE:
-				setValue((ValueType)null);
-				return;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__LIST_ENTRIES:
-				setListEntries((ListEntriesType)null);
-				return;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__DESCRIPTION:
-				return description != null && !description.isEmpty();
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__DISPLAY_NAME:
-				return displayName != null && !displayName.isEmpty();
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__ICON:
-				return icon != null && !icon.isEmpty();
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__PROPERTY_NAME:
-				return propertyName != null;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__PROPERTY_CLASS:
-				return propertyClass != null;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__MAP_ENTRIES:
-				return mapEntries != null;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__NULL_VALUE:
-				return nullValue != null;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__VALUE:
-				return value != null;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__LIST_ENTRIES:
-				return listEntries != null;
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ManagedPropertyTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/MapEntriesTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/MapEntriesTypeImpl.java
deleted file mode 100644
index 26efec3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/MapEntriesTypeImpl.java
+++ /dev/null
@@ -1,366 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.KeyClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType;
-import org.eclipse.jst.jsf.facesconfig.emf.MapEntryType;
-import org.eclipse.jst.jsf.facesconfig.emf.ValueClassType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Map Entries Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.MapEntriesTypeImpl#getKeyClass <em>Key Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.MapEntriesTypeImpl#getValueClass <em>Value Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.MapEntriesTypeImpl#getMapEntry <em>Map Entry</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.MapEntriesTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class MapEntriesTypeImpl extends EObjectImpl implements MapEntriesType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getKeyClass() <em>Key Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getKeyClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected KeyClassType keyClass;
-
-    /**
-	 * The cached value of the '{@link #getValueClass() <em>Value Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getValueClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected ValueClassType valueClass;
-
-    /**
-	 * The cached value of the '{@link #getMapEntry() <em>Map Entry</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getMapEntry()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList mapEntry;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected MapEntriesTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.MAP_ENTRIES_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public KeyClassType getKeyClass() {
-		return keyClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newKeyClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetKeyClass(KeyClassType newKeyClass, NotificationChain msgs) {
-		KeyClassType oldKeyClass = keyClass;
-		keyClass = newKeyClass;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MAP_ENTRIES_TYPE__KEY_CLASS, oldKeyClass, newKeyClass);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setKeyClass(KeyClassType newKeyClass) {
-		if (newKeyClass != keyClass) {
-			NotificationChain msgs = null;
-			if (keyClass != null)
-				msgs = ((InternalEObject)keyClass).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MAP_ENTRIES_TYPE__KEY_CLASS, null, msgs);
-			if (newKeyClass != null)
-				msgs = ((InternalEObject)newKeyClass).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MAP_ENTRIES_TYPE__KEY_CLASS, null, msgs);
-			msgs = basicSetKeyClass(newKeyClass, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MAP_ENTRIES_TYPE__KEY_CLASS, newKeyClass, newKeyClass));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValueClassType getValueClass() {
-		return valueClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newValueClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetValueClass(ValueClassType newValueClass, NotificationChain msgs) {
-		ValueClassType oldValueClass = valueClass;
-		valueClass = newValueClass;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MAP_ENTRIES_TYPE__VALUE_CLASS, oldValueClass, newValueClass);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setValueClass(ValueClassType newValueClass) {
-		if (newValueClass != valueClass) {
-			NotificationChain msgs = null;
-			if (valueClass != null)
-				msgs = ((InternalEObject)valueClass).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MAP_ENTRIES_TYPE__VALUE_CLASS, null, msgs);
-			if (newValueClass != null)
-				msgs = ((InternalEObject)newValueClass).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MAP_ENTRIES_TYPE__VALUE_CLASS, null, msgs);
-			msgs = basicSetValueClass(newValueClass, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MAP_ENTRIES_TYPE__VALUE_CLASS, newValueClass, newValueClass));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getMapEntry() {
-		if (mapEntry == null) {
-			mapEntry = new EObjectContainmentEList(MapEntryType.class, this, FacesConfigPackage.MAP_ENTRIES_TYPE__MAP_ENTRY);
-		}
-		return mapEntry;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MAP_ENTRIES_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__KEY_CLASS:
-				return basicSetKeyClass(null, msgs);
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__VALUE_CLASS:
-				return basicSetValueClass(null, msgs);
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__MAP_ENTRY:
-				return ((InternalEList)getMapEntry()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__KEY_CLASS:
-				return getKeyClass();
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__VALUE_CLASS:
-				return getValueClass();
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__MAP_ENTRY:
-				return getMapEntry();
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__KEY_CLASS:
-				setKeyClass((KeyClassType)newValue);
-				return;
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__VALUE_CLASS:
-				setValueClass((ValueClassType)newValue);
-				return;
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__MAP_ENTRY:
-				getMapEntry().clear();
-				getMapEntry().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__KEY_CLASS:
-				setKeyClass((KeyClassType)null);
-				return;
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__VALUE_CLASS:
-				setValueClass((ValueClassType)null);
-				return;
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__MAP_ENTRY:
-				getMapEntry().clear();
-				return;
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__KEY_CLASS:
-				return keyClass != null;
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__VALUE_CLASS:
-				return valueClass != null;
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__MAP_ENTRY:
-				return mapEntry != null && !mapEntry.isEmpty();
-			case FacesConfigPackage.MAP_ENTRIES_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //MapEntriesTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/MapEntryTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/MapEntryTypeImpl.java
deleted file mode 100644
index 74ceff0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/MapEntryTypeImpl.java
+++ /dev/null
@@ -1,394 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.KeyType;
-import org.eclipse.jst.jsf.facesconfig.emf.MapEntryType;
-import org.eclipse.jst.jsf.facesconfig.emf.NullValueType;
-import org.eclipse.jst.jsf.facesconfig.emf.ValueType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Map Entry Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.MapEntryTypeImpl#getKey <em>Key</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.MapEntryTypeImpl#getNullValue <em>Null Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.MapEntryTypeImpl#getValue <em>Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.MapEntryTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class MapEntryTypeImpl extends EObjectImpl implements MapEntryType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getKey() <em>Key</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getKey()
-	 * @generated
-	 * @ordered
-	 */
-	protected KeyType key;
-
-    /**
-	 * The cached value of the '{@link #getNullValue() <em>Null Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getNullValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected NullValueType nullValue;
-
-    /**
-	 * The cached value of the '{@link #getValue() <em>Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected ValueType value;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected MapEntryTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.MAP_ENTRY_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public KeyType getKey() {
-		return key;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newKey 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetKey(KeyType newKey, NotificationChain msgs) {
-		KeyType oldKey = key;
-		key = newKey;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MAP_ENTRY_TYPE__KEY, oldKey, newKey);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setKey(KeyType newKey) {
-		if (newKey != key) {
-			NotificationChain msgs = null;
-			if (key != null)
-				msgs = ((InternalEObject)key).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MAP_ENTRY_TYPE__KEY, null, msgs);
-			if (newKey != null)
-				msgs = ((InternalEObject)newKey).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MAP_ENTRY_TYPE__KEY, null, msgs);
-			msgs = basicSetKey(newKey, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MAP_ENTRY_TYPE__KEY, newKey, newKey));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NullValueType getNullValue() {
-		return nullValue;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newNullValue 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetNullValue(NullValueType newNullValue, NotificationChain msgs) {
-		NullValueType oldNullValue = nullValue;
-		nullValue = newNullValue;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MAP_ENTRY_TYPE__NULL_VALUE, oldNullValue, newNullValue);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setNullValue(NullValueType newNullValue) {
-		if (newNullValue != nullValue) {
-			NotificationChain msgs = null;
-			if (nullValue != null)
-				msgs = ((InternalEObject)nullValue).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MAP_ENTRY_TYPE__NULL_VALUE, null, msgs);
-			if (newNullValue != null)
-				msgs = ((InternalEObject)newNullValue).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MAP_ENTRY_TYPE__NULL_VALUE, null, msgs);
-			msgs = basicSetNullValue(newNullValue, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MAP_ENTRY_TYPE__NULL_VALUE, newNullValue, newNullValue));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValueType getValue() {
-		return value;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newValue 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetValue(ValueType newValue, NotificationChain msgs) {
-		ValueType oldValue = value;
-		value = newValue;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MAP_ENTRY_TYPE__VALUE, oldValue, newValue);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setValue(ValueType newValue) {
-		if (newValue != value) {
-			NotificationChain msgs = null;
-			if (value != null)
-				msgs = ((InternalEObject)value).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MAP_ENTRY_TYPE__VALUE, null, msgs);
-			if (newValue != null)
-				msgs = ((InternalEObject)newValue).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.MAP_ENTRY_TYPE__VALUE, null, msgs);
-			msgs = basicSetValue(newValue, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MAP_ENTRY_TYPE__VALUE, newValue, newValue));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MAP_ENTRY_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.MAP_ENTRY_TYPE__KEY:
-				return basicSetKey(null, msgs);
-			case FacesConfigPackage.MAP_ENTRY_TYPE__NULL_VALUE:
-				return basicSetNullValue(null, msgs);
-			case FacesConfigPackage.MAP_ENTRY_TYPE__VALUE:
-				return basicSetValue(null, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.MAP_ENTRY_TYPE__KEY:
-				return getKey();
-			case FacesConfigPackage.MAP_ENTRY_TYPE__NULL_VALUE:
-				return getNullValue();
-			case FacesConfigPackage.MAP_ENTRY_TYPE__VALUE:
-				return getValue();
-			case FacesConfigPackage.MAP_ENTRY_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.MAP_ENTRY_TYPE__KEY:
-				setKey((KeyType)newValue);
-				return;
-			case FacesConfigPackage.MAP_ENTRY_TYPE__NULL_VALUE:
-				setNullValue((NullValueType)newValue);
-				return;
-			case FacesConfigPackage.MAP_ENTRY_TYPE__VALUE:
-				setValue((ValueType)newValue);
-				return;
-			case FacesConfigPackage.MAP_ENTRY_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.MAP_ENTRY_TYPE__KEY:
-				setKey((KeyType)null);
-				return;
-			case FacesConfigPackage.MAP_ENTRY_TYPE__NULL_VALUE:
-				setNullValue((NullValueType)null);
-				return;
-			case FacesConfigPackage.MAP_ENTRY_TYPE__VALUE:
-				setValue((ValueType)null);
-				return;
-			case FacesConfigPackage.MAP_ENTRY_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.MAP_ENTRY_TYPE__KEY:
-				return key != null;
-			case FacesConfigPackage.MAP_ENTRY_TYPE__NULL_VALUE:
-				return nullValue != null;
-			case FacesConfigPackage.MAP_ENTRY_TYPE__VALUE:
-				return value != null;
-			case FacesConfigPackage.MAP_ENTRY_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //MapEntryTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/MessageBundleTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/MessageBundleTypeImpl.java
deleted file mode 100644
index 92eda01..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/MessageBundleTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.MessageBundleType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Message Bundle Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.MessageBundleTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.MessageBundleTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class MessageBundleTypeImpl extends EObjectImpl implements MessageBundleType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected MessageBundleTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.MESSAGE_BUNDLE_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MESSAGE_BUNDLE_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.MESSAGE_BUNDLE_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.MESSAGE_BUNDLE_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.MESSAGE_BUNDLE_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.MESSAGE_BUNDLE_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.MESSAGE_BUNDLE_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.MESSAGE_BUNDLE_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.MESSAGE_BUNDLE_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.MESSAGE_BUNDLE_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.MESSAGE_BUNDLE_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //MessageBundleTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/NameTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/NameTypeImpl.java
deleted file mode 100644
index 511b347..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/NameTypeImpl.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.NameType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Name Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NameTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NameTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class NameTypeImpl extends EObjectImpl implements NameType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected NameTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.NAME_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.NAME_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.NAME_TYPE__ID, oldId, id));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.NAME_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.NAME_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.NAME_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.NAME_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.NAME_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.NAME_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.NAME_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.NAME_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //NameTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/NavigationCaseTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/NavigationCaseTypeImpl.java
deleted file mode 100644
index ce9d461..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/NavigationCaseTypeImpl.java
+++ /dev/null
@@ -1,650 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.DescriptionType;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FromActionType;
-import org.eclipse.jst.jsf.facesconfig.emf.FromOutcomeType;
-import org.eclipse.jst.jsf.facesconfig.emf.IconType;
-import org.eclipse.jst.jsf.facesconfig.emf.IfType;
-import org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType;
-import org.eclipse.jst.jsf.facesconfig.emf.RedirectType;
-import org.eclipse.jst.jsf.facesconfig.emf.ToViewIdType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Navigation Case Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationCaseTypeImpl#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationCaseTypeImpl#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationCaseTypeImpl#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationCaseTypeImpl#getFromAction <em>From Action</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationCaseTypeImpl#getFromOutcome <em>From Outcome</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationCaseTypeImpl#getIf <em>If</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationCaseTypeImpl#getToViewId <em>To View Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationCaseTypeImpl#getRedirect <em>Redirect</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationCaseTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class NavigationCaseTypeImpl extends EObjectImpl implements NavigationCaseType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getDescription() <em>Description</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDescription()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList description;
-
-    /**
-	 * The cached value of the '{@link #getDisplayName() <em>Display Name</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDisplayName()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList displayName;
-
-    /**
-	 * The cached value of the '{@link #getIcon() <em>Icon</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getIcon()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList icon;
-
-    /**
-	 * The cached value of the '{@link #getFromAction() <em>From Action</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getFromAction()
-	 * @generated
-	 * @ordered
-	 */
-	protected FromActionType fromAction;
-
-    /**
-	 * The cached value of the '{@link #getFromOutcome() <em>From Outcome</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getFromOutcome()
-	 * @generated
-	 * @ordered
-	 */
-	protected FromOutcomeType fromOutcome;
-
-    /**
-	 * The cached value of the '{@link #getIf() <em>If</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getIf()
-	 * @generated
-	 * @ordered
-	 */
-	protected IfType if_;
-
-				/**
-	 * The cached value of the '{@link #getToViewId() <em>To View Id</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getToViewId()
-	 * @generated
-	 * @ordered
-	 */
-	protected ToViewIdType toViewId;
-
-    /**
-	 * The cached value of the '{@link #getRedirect() <em>Redirect</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getRedirect()
-	 * @generated
-	 * @ordered
-	 */
-	protected RedirectType redirect;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected NavigationCaseTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.NAVIGATION_CASE_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDescription() {
-		if (description == null) {
-			description = new EObjectContainmentEList(DescriptionType.class, this, FacesConfigPackage.NAVIGATION_CASE_TYPE__DESCRIPTION);
-		}
-		return description;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDisplayName() {
-		if (displayName == null) {
-			displayName = new EObjectContainmentEList(DisplayNameType.class, this, FacesConfigPackage.NAVIGATION_CASE_TYPE__DISPLAY_NAME);
-		}
-		return displayName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getIcon() {
-		if (icon == null) {
-			icon = new EObjectContainmentEList(IconType.class, this, FacesConfigPackage.NAVIGATION_CASE_TYPE__ICON);
-		}
-		return icon;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FromActionType getFromAction() {
-		return fromAction;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newFromAction 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetFromAction(FromActionType newFromAction, NotificationChain msgs) {
-		FromActionType oldFromAction = fromAction;
-		fromAction = newFromAction;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.NAVIGATION_CASE_TYPE__FROM_ACTION, oldFromAction, newFromAction);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setFromAction(FromActionType newFromAction) {
-		if (newFromAction != fromAction) {
-			NotificationChain msgs = null;
-			if (fromAction != null)
-				msgs = ((InternalEObject)fromAction).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.NAVIGATION_CASE_TYPE__FROM_ACTION, null, msgs);
-			if (newFromAction != null)
-				msgs = ((InternalEObject)newFromAction).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.NAVIGATION_CASE_TYPE__FROM_ACTION, null, msgs);
-			msgs = basicSetFromAction(newFromAction, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.NAVIGATION_CASE_TYPE__FROM_ACTION, newFromAction, newFromAction));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FromOutcomeType getFromOutcome() {
-		return fromOutcome;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newFromOutcome 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetFromOutcome(FromOutcomeType newFromOutcome, NotificationChain msgs) {
-		FromOutcomeType oldFromOutcome = fromOutcome;
-		fromOutcome = newFromOutcome;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.NAVIGATION_CASE_TYPE__FROM_OUTCOME, oldFromOutcome, newFromOutcome);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setFromOutcome(FromOutcomeType newFromOutcome) {
-		if (newFromOutcome != fromOutcome) {
-			NotificationChain msgs = null;
-			if (fromOutcome != null)
-				msgs = ((InternalEObject)fromOutcome).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.NAVIGATION_CASE_TYPE__FROM_OUTCOME, null, msgs);
-			if (newFromOutcome != null)
-				msgs = ((InternalEObject)newFromOutcome).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.NAVIGATION_CASE_TYPE__FROM_OUTCOME, null, msgs);
-			msgs = basicSetFromOutcome(newFromOutcome, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.NAVIGATION_CASE_TYPE__FROM_OUTCOME, newFromOutcome, newFromOutcome));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public IfType getIf() {
-		return if_;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * @param newIf 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetIf(IfType newIf, NotificationChain msgs) {
-		IfType oldIf = if_;
-		if_ = newIf;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.NAVIGATION_CASE_TYPE__IF, oldIf, newIf);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setIf(IfType newIf) {
-		if (newIf != if_) {
-			NotificationChain msgs = null;
-			if (if_ != null)
-				msgs = ((InternalEObject)if_).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.NAVIGATION_CASE_TYPE__IF, null, msgs);
-			if (newIf != null)
-				msgs = ((InternalEObject)newIf).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.NAVIGATION_CASE_TYPE__IF, null, msgs);
-			msgs = basicSetIf(newIf, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.NAVIGATION_CASE_TYPE__IF, newIf, newIf));
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ToViewIdType getToViewId() {
-		return toViewId;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newToViewId 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetToViewId(ToViewIdType newToViewId, NotificationChain msgs) {
-		ToViewIdType oldToViewId = toViewId;
-		toViewId = newToViewId;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.NAVIGATION_CASE_TYPE__TO_VIEW_ID, oldToViewId, newToViewId);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setToViewId(ToViewIdType newToViewId) {
-		if (newToViewId != toViewId) {
-			NotificationChain msgs = null;
-			if (toViewId != null)
-				msgs = ((InternalEObject)toViewId).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.NAVIGATION_CASE_TYPE__TO_VIEW_ID, null, msgs);
-			if (newToViewId != null)
-				msgs = ((InternalEObject)newToViewId).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.NAVIGATION_CASE_TYPE__TO_VIEW_ID, null, msgs);
-			msgs = basicSetToViewId(newToViewId, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.NAVIGATION_CASE_TYPE__TO_VIEW_ID, newToViewId, newToViewId));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RedirectType getRedirect() {
-		return redirect;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newRedirect 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetRedirect(RedirectType newRedirect, NotificationChain msgs) {
-		RedirectType oldRedirect = redirect;
-		redirect = newRedirect;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.NAVIGATION_CASE_TYPE__REDIRECT, oldRedirect, newRedirect);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setRedirect(RedirectType newRedirect) {
-		if (newRedirect != redirect) {
-			NotificationChain msgs = null;
-			if (redirect != null)
-				msgs = ((InternalEObject)redirect).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.NAVIGATION_CASE_TYPE__REDIRECT, null, msgs);
-			if (newRedirect != null)
-				msgs = ((InternalEObject)newRedirect).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.NAVIGATION_CASE_TYPE__REDIRECT, null, msgs);
-			msgs = basicSetRedirect(newRedirect, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.NAVIGATION_CASE_TYPE__REDIRECT, newRedirect, newRedirect));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.NAVIGATION_CASE_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__DESCRIPTION:
-				return ((InternalEList)getDescription()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__DISPLAY_NAME:
-				return ((InternalEList)getDisplayName()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__ICON:
-				return ((InternalEList)getIcon()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__FROM_ACTION:
-				return basicSetFromAction(null, msgs);
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__FROM_OUTCOME:
-				return basicSetFromOutcome(null, msgs);
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__IF:
-				return basicSetIf(null, msgs);
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__TO_VIEW_ID:
-				return basicSetToViewId(null, msgs);
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__REDIRECT:
-				return basicSetRedirect(null, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__DESCRIPTION:
-				return getDescription();
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__DISPLAY_NAME:
-				return getDisplayName();
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__ICON:
-				return getIcon();
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__FROM_ACTION:
-				return getFromAction();
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__FROM_OUTCOME:
-				return getFromOutcome();
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__IF:
-				return getIf();
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__TO_VIEW_ID:
-				return getToViewId();
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__REDIRECT:
-				return getRedirect();
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__DESCRIPTION:
-				getDescription().clear();
-				getDescription().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				getDisplayName().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__ICON:
-				getIcon().clear();
-				getIcon().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__FROM_ACTION:
-				setFromAction((FromActionType)newValue);
-				return;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__FROM_OUTCOME:
-				setFromOutcome((FromOutcomeType)newValue);
-				return;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__IF:
-				setIf((IfType)newValue);
-				return;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__TO_VIEW_ID:
-				setToViewId((ToViewIdType)newValue);
-				return;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__REDIRECT:
-				setRedirect((RedirectType)newValue);
-				return;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__DESCRIPTION:
-				getDescription().clear();
-				return;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				return;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__ICON:
-				getIcon().clear();
-				return;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__FROM_ACTION:
-				setFromAction((FromActionType)null);
-				return;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__FROM_OUTCOME:
-				setFromOutcome((FromOutcomeType)null);
-				return;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__IF:
-				setIf((IfType)null);
-				return;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__TO_VIEW_ID:
-				setToViewId((ToViewIdType)null);
-				return;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__REDIRECT:
-				setRedirect((RedirectType)null);
-				return;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__DESCRIPTION:
-				return description != null && !description.isEmpty();
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__DISPLAY_NAME:
-				return displayName != null && !displayName.isEmpty();
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__ICON:
-				return icon != null && !icon.isEmpty();
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__FROM_ACTION:
-				return fromAction != null;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__FROM_OUTCOME:
-				return fromOutcome != null;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__IF:
-				return if_ != null;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__TO_VIEW_ID:
-				return toViewId != null;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__REDIRECT:
-				return redirect != null;
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //NavigationCaseTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/NavigationHandlerTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/NavigationHandlerTypeImpl.java
deleted file mode 100644
index 814a158..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/NavigationHandlerTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.NavigationHandlerType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Navigation Handler Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationHandlerTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationHandlerTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class NavigationHandlerTypeImpl extends EObjectImpl implements NavigationHandlerType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected NavigationHandlerTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.NAVIGATION_HANDLER_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.NAVIGATION_HANDLER_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.NAVIGATION_HANDLER_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.NAVIGATION_HANDLER_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.NAVIGATION_HANDLER_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.NAVIGATION_HANDLER_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.NAVIGATION_HANDLER_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.NAVIGATION_HANDLER_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.NAVIGATION_HANDLER_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.NAVIGATION_HANDLER_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.NAVIGATION_HANDLER_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //NavigationHandlerTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/NavigationRuleExtensionTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/NavigationRuleExtensionTypeImpl.java
deleted file mode 100644
index b05ec70..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/NavigationRuleExtensionTypeImpl.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleExtensionType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Navigation Rule Extension Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * </p>
- *
- * @generated
- */
-public class NavigationRuleExtensionTypeImpl extends ExtensionTypeImpl implements NavigationRuleExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    @SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected NavigationRuleExtensionTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.NAVIGATION_RULE_EXTENSION_TYPE;
-	}
-
-} //NavigationRuleExtensionTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/NavigationRuleTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/NavigationRuleTypeImpl.java
deleted file mode 100644
index 3007f16..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/NavigationRuleTypeImpl.java
+++ /dev/null
@@ -1,444 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.DescriptionType;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FromViewIdType;
-import org.eclipse.jst.jsf.facesconfig.emf.IconType;
-import org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType;
-import org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Navigation Rule Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationRuleTypeImpl#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationRuleTypeImpl#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationRuleTypeImpl#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationRuleTypeImpl#getFromViewId <em>From View Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationRuleTypeImpl#getNavigationCase <em>Navigation Case</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationRuleTypeImpl#getNavigationRuleExtension <em>Navigation Rule Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NavigationRuleTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class NavigationRuleTypeImpl extends EObjectImpl implements NavigationRuleType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getDescription() <em>Description</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDescription()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList description;
-
-    /**
-	 * The cached value of the '{@link #getDisplayName() <em>Display Name</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDisplayName()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList displayName;
-
-    /**
-	 * The cached value of the '{@link #getIcon() <em>Icon</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getIcon()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList icon;
-
-    /**
-	 * The cached value of the '{@link #getFromViewId() <em>From View Id</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getFromViewId()
-	 * @generated
-	 * @ordered
-	 */
-	protected FromViewIdType fromViewId;
-
-    /**
-	 * The cached value of the '{@link #getNavigationCase() <em>Navigation Case</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getNavigationCase()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList navigationCase;
-
-    /**
-	 * The cached value of the '{@link #getNavigationRuleExtension() <em>Navigation Rule Extension</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getNavigationRuleExtension()
-	 * @generated
-	 * @ordered
-	 */
-    protected EList navigationRuleExtension;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected NavigationRuleTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.NAVIGATION_RULE_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDescription() {
-		if (description == null) {
-			description = new EObjectContainmentEList(DescriptionType.class, this, FacesConfigPackage.NAVIGATION_RULE_TYPE__DESCRIPTION);
-		}
-		return description;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDisplayName() {
-		if (displayName == null) {
-			displayName = new EObjectContainmentEList(DisplayNameType.class, this, FacesConfigPackage.NAVIGATION_RULE_TYPE__DISPLAY_NAME);
-		}
-		return displayName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getIcon() {
-		if (icon == null) {
-			icon = new EObjectContainmentEList(IconType.class, this, FacesConfigPackage.NAVIGATION_RULE_TYPE__ICON);
-		}
-		return icon;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FromViewIdType getFromViewId() {
-		return fromViewId;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newFromViewId 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetFromViewId(FromViewIdType newFromViewId, NotificationChain msgs) {
-		FromViewIdType oldFromViewId = fromViewId;
-		fromViewId = newFromViewId;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.NAVIGATION_RULE_TYPE__FROM_VIEW_ID, oldFromViewId, newFromViewId);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setFromViewId(FromViewIdType newFromViewId) {
-		if (newFromViewId != fromViewId) {
-			NotificationChain msgs = null;
-			if (fromViewId != null)
-				msgs = ((InternalEObject)fromViewId).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.NAVIGATION_RULE_TYPE__FROM_VIEW_ID, null, msgs);
-			if (newFromViewId != null)
-				msgs = ((InternalEObject)newFromViewId).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.NAVIGATION_RULE_TYPE__FROM_VIEW_ID, null, msgs);
-			msgs = basicSetFromViewId(newFromViewId, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.NAVIGATION_RULE_TYPE__FROM_VIEW_ID, newFromViewId, newFromViewId));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getNavigationCase() {
-		if (navigationCase == null) {
-			navigationCase = new EObjectContainmentEList(NavigationCaseType.class, this, FacesConfigPackage.NAVIGATION_RULE_TYPE__NAVIGATION_CASE);
-		}
-		return navigationCase;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EList getNavigationRuleExtension() {
-		if (navigationRuleExtension == null) {
-			navigationRuleExtension = new EObjectContainmentEList(NavigationRuleExtensionType.class, this, FacesConfigPackage.NAVIGATION_RULE_TYPE__NAVIGATION_RULE_EXTENSION);
-		}
-		return navigationRuleExtension;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.NAVIGATION_RULE_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__DESCRIPTION:
-				return ((InternalEList)getDescription()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__DISPLAY_NAME:
-				return ((InternalEList)getDisplayName()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__ICON:
-				return ((InternalEList)getIcon()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__FROM_VIEW_ID:
-				return basicSetFromViewId(null, msgs);
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__NAVIGATION_CASE:
-				return ((InternalEList)getNavigationCase()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__NAVIGATION_RULE_EXTENSION:
-				return ((InternalEList)getNavigationRuleExtension()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__DESCRIPTION:
-				return getDescription();
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__DISPLAY_NAME:
-				return getDisplayName();
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__ICON:
-				return getIcon();
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__FROM_VIEW_ID:
-				return getFromViewId();
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__NAVIGATION_CASE:
-				return getNavigationCase();
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__NAVIGATION_RULE_EXTENSION:
-				return getNavigationRuleExtension();
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__DESCRIPTION:
-				getDescription().clear();
-				getDescription().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				getDisplayName().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__ICON:
-				getIcon().clear();
-				getIcon().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__FROM_VIEW_ID:
-				setFromViewId((FromViewIdType)newValue);
-				return;
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__NAVIGATION_CASE:
-				getNavigationCase().clear();
-				getNavigationCase().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__NAVIGATION_RULE_EXTENSION:
-				getNavigationRuleExtension().clear();
-				getNavigationRuleExtension().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__DESCRIPTION:
-				getDescription().clear();
-				return;
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				return;
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__ICON:
-				getIcon().clear();
-				return;
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__FROM_VIEW_ID:
-				setFromViewId((FromViewIdType)null);
-				return;
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__NAVIGATION_CASE:
-				getNavigationCase().clear();
-				return;
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__NAVIGATION_RULE_EXTENSION:
-				getNavigationRuleExtension().clear();
-				return;
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__DESCRIPTION:
-				return description != null && !description.isEmpty();
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__DISPLAY_NAME:
-				return displayName != null && !displayName.isEmpty();
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__ICON:
-				return icon != null && !icon.isEmpty();
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__FROM_VIEW_ID:
-				return fromViewId != null;
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__NAVIGATION_CASE:
-				return navigationCase != null && !navigationCase.isEmpty();
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__NAVIGATION_RULE_EXTENSION:
-				return navigationRuleExtension != null && !navigationRuleExtension.isEmpty();
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //NavigationRuleTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/NullValueTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/NullValueTypeImpl.java
deleted file mode 100644
index e42c2b8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/NullValueTypeImpl.java
+++ /dev/null
@@ -1,171 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.NullValueType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Null Value Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.NullValueTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class NullValueTypeImpl extends EObjectImpl implements NullValueType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected NullValueTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.NULL_VALUE_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.NULL_VALUE_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.NULL_VALUE_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.NULL_VALUE_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.NULL_VALUE_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.NULL_VALUE_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //NullValueTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/OrderingOrderingTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/OrderingOrderingTypeImpl.java
deleted file mode 100644
index 8e118cb..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/OrderingOrderingTypeImpl.java
+++ /dev/null
@@ -1,228 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.NameType;
-import org.eclipse.jst.jsf.facesconfig.emf.OrderingOrderingType;
-import org.eclipse.jst.jsf.facesconfig.emf.OrderingOthersType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Ordering Ordering Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.OrderingOrderingTypeImpl#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.OrderingOrderingTypeImpl#getOthers <em>Others</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class OrderingOrderingTypeImpl extends EObjectImpl implements OrderingOrderingType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The cached value of the '{@link #getName() <em>Name</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getName()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList name;
-
-	/**
-	 * The cached value of the '{@link #getOthers() <em>Others</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getOthers()
-	 * @generated
-	 * @ordered
-	 */
-	protected OrderingOthersType others;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected OrderingOrderingTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.ORDERING_ORDERING_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getName() {
-		if (name == null) {
-			name = new EObjectContainmentEList(NameType.class, this, FacesConfigPackage.ORDERING_ORDERING_TYPE__NAME);
-		}
-		return name;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public OrderingOthersType getOthers() {
-		return others;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * @param newOthers 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetOthers(OrderingOthersType newOthers, NotificationChain msgs) {
-		OrderingOthersType oldOthers = others;
-		others = newOthers;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ORDERING_ORDERING_TYPE__OTHERS, oldOthers, newOthers);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setOthers(OrderingOthersType newOthers) {
-		if (newOthers != others) {
-			NotificationChain msgs = null;
-			if (others != null)
-				msgs = ((InternalEObject)others).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.ORDERING_ORDERING_TYPE__OTHERS, null, msgs);
-			if (newOthers != null)
-				msgs = ((InternalEObject)newOthers).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.ORDERING_ORDERING_TYPE__OTHERS, null, msgs);
-			msgs = basicSetOthers(newOthers, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ORDERING_ORDERING_TYPE__OTHERS, newOthers, newOthers));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.ORDERING_ORDERING_TYPE__NAME:
-				return ((InternalEList)getName()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.ORDERING_ORDERING_TYPE__OTHERS:
-				return basicSetOthers(null, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.ORDERING_ORDERING_TYPE__NAME:
-				return getName();
-			case FacesConfigPackage.ORDERING_ORDERING_TYPE__OTHERS:
-				return getOthers();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.ORDERING_ORDERING_TYPE__NAME:
-				getName().clear();
-				getName().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.ORDERING_ORDERING_TYPE__OTHERS:
-				setOthers((OrderingOthersType)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.ORDERING_ORDERING_TYPE__NAME:
-				getName().clear();
-				return;
-			case FacesConfigPackage.ORDERING_ORDERING_TYPE__OTHERS:
-				setOthers((OrderingOthersType)null);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.ORDERING_ORDERING_TYPE__NAME:
-				return name != null && !name.isEmpty();
-			case FacesConfigPackage.ORDERING_ORDERING_TYPE__OTHERS:
-				return others != null;
-		}
-		return super.eIsSet(featureID);
-	}
-
-} //OrderingOrderingTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/OrderingOthersTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/OrderingOthersTypeImpl.java
deleted file mode 100644
index fe8c019..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/OrderingOthersTypeImpl.java
+++ /dev/null
@@ -1,170 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.OrderingOthersType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Ordering Others Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.OrderingOthersTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class OrderingOthersTypeImpl extends EObjectImpl implements OrderingOthersType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected OrderingOthersTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.ORDERING_OTHERS_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ORDERING_OTHERS_TYPE__ID, oldId, id));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.ORDERING_OTHERS_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.ORDERING_OTHERS_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.ORDERING_OTHERS_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.ORDERING_OTHERS_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //OrderingOthersTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/OrderingTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/OrderingTypeImpl.java
deleted file mode 100644
index a5402e6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/OrderingTypeImpl.java
+++ /dev/null
@@ -1,255 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.OrderingOrderingType;
-import org.eclipse.jst.jsf.facesconfig.emf.OrderingType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Ordering Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.OrderingTypeImpl#getBefore <em>Before</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.OrderingTypeImpl#getAfter <em>After</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class OrderingTypeImpl extends EObjectImpl implements OrderingType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The cached value of the '{@link #getBefore() <em>Before</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getBefore()
-	 * @generated
-	 * @ordered
-	 */
-	protected OrderingOrderingType before;
-
-	/**
-	 * The cached value of the '{@link #getAfter() <em>After</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getAfter()
-	 * @generated
-	 * @ordered
-	 */
-	protected OrderingOrderingType after;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected OrderingTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.ORDERING_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public OrderingOrderingType getBefore() {
-		return before;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * @param newBefore 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetBefore(OrderingOrderingType newBefore, NotificationChain msgs) {
-		OrderingOrderingType oldBefore = before;
-		before = newBefore;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ORDERING_TYPE__BEFORE, oldBefore, newBefore);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setBefore(OrderingOrderingType newBefore) {
-		if (newBefore != before) {
-			NotificationChain msgs = null;
-			if (before != null)
-				msgs = ((InternalEObject)before).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.ORDERING_TYPE__BEFORE, null, msgs);
-			if (newBefore != null)
-				msgs = ((InternalEObject)newBefore).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.ORDERING_TYPE__BEFORE, null, msgs);
-			msgs = basicSetBefore(newBefore, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ORDERING_TYPE__BEFORE, newBefore, newBefore));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public OrderingOrderingType getAfter() {
-		return after;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * @param newAfter 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetAfter(OrderingOrderingType newAfter, NotificationChain msgs) {
-		OrderingOrderingType oldAfter = after;
-		after = newAfter;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ORDERING_TYPE__AFTER, oldAfter, newAfter);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setAfter(OrderingOrderingType newAfter) {
-		if (newAfter != after) {
-			NotificationChain msgs = null;
-			if (after != null)
-				msgs = ((InternalEObject)after).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.ORDERING_TYPE__AFTER, null, msgs);
-			if (newAfter != null)
-				msgs = ((InternalEObject)newAfter).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.ORDERING_TYPE__AFTER, null, msgs);
-			msgs = basicSetAfter(newAfter, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.ORDERING_TYPE__AFTER, newAfter, newAfter));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.ORDERING_TYPE__BEFORE:
-				return basicSetBefore(null, msgs);
-			case FacesConfigPackage.ORDERING_TYPE__AFTER:
-				return basicSetAfter(null, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.ORDERING_TYPE__BEFORE:
-				return getBefore();
-			case FacesConfigPackage.ORDERING_TYPE__AFTER:
-				return getAfter();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.ORDERING_TYPE__BEFORE:
-				setBefore((OrderingOrderingType)newValue);
-				return;
-			case FacesConfigPackage.ORDERING_TYPE__AFTER:
-				setAfter((OrderingOrderingType)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.ORDERING_TYPE__BEFORE:
-				setBefore((OrderingOrderingType)null);
-				return;
-			case FacesConfigPackage.ORDERING_TYPE__AFTER:
-				setAfter((OrderingOrderingType)null);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.ORDERING_TYPE__BEFORE:
-				return before != null;
-			case FacesConfigPackage.ORDERING_TYPE__AFTER:
-				return after != null;
-		}
-		return super.eIsSet(featureID);
-	}
-
-} //OrderingTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/PartialViewContextFactoryTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/PartialViewContextFactoryTypeImpl.java
deleted file mode 100644
index 7c77fd8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/PartialViewContextFactoryTypeImpl.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.PartialViewContextFactoryType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Partial View Context Factory Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PartialViewContextFactoryTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PartialViewContextFactoryTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PartialViewContextFactoryTypeImpl extends EObjectImpl implements PartialViewContextFactoryType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PartialViewContextFactoryTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.PARTIAL_VIEW_CONTEXT_FACTORY_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.PARTIAL_VIEW_CONTEXT_FACTORY_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.PARTIAL_VIEW_CONTEXT_FACTORY_TYPE__ID, oldId, id));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.PARTIAL_VIEW_CONTEXT_FACTORY_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.PARTIAL_VIEW_CONTEXT_FACTORY_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.PARTIAL_VIEW_CONTEXT_FACTORY_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.PARTIAL_VIEW_CONTEXT_FACTORY_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.PARTIAL_VIEW_CONTEXT_FACTORY_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.PARTIAL_VIEW_CONTEXT_FACTORY_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.PARTIAL_VIEW_CONTEXT_FACTORY_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.PARTIAL_VIEW_CONTEXT_FACTORY_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //PartialViewContextFactoryTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/PhaseListenerTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/PhaseListenerTypeImpl.java
deleted file mode 100644
index 18fe290..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/PhaseListenerTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.PhaseListenerType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Phase Listener Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PhaseListenerTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PhaseListenerTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PhaseListenerTypeImpl extends EObjectImpl implements PhaseListenerType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PhaseListenerTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.PHASE_LISTENER_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.PHASE_LISTENER_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.PHASE_LISTENER_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.PHASE_LISTENER_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.PHASE_LISTENER_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.PHASE_LISTENER_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.PHASE_LISTENER_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.PHASE_LISTENER_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.PHASE_LISTENER_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.PHASE_LISTENER_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.PHASE_LISTENER_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //PhaseListenerTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/PropertyClassTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/PropertyClassTypeImpl.java
deleted file mode 100644
index aa19cde..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/PropertyClassTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.PropertyClassType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Property Class Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyClassTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyClassTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PropertyClassTypeImpl extends EObjectImpl implements PropertyClassType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PropertyClassTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.PROPERTY_CLASS_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.PROPERTY_CLASS_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.PROPERTY_CLASS_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.PROPERTY_CLASS_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.PROPERTY_CLASS_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.PROPERTY_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.PROPERTY_CLASS_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.PROPERTY_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.PROPERTY_CLASS_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.PROPERTY_CLASS_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.PROPERTY_CLASS_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //PropertyClassTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/PropertyExtensionTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/PropertyExtensionTypeImpl.java
deleted file mode 100644
index 1c6d84e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/PropertyExtensionTypeImpl.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.PropertyExtensionType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Property Extension Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * </p>
- *
- * @generated
- */
-public class PropertyExtensionTypeImpl extends ExtensionTypeImpl implements PropertyExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PropertyExtensionTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.PROPERTY_EXTENSION_TYPE;
-	}
-
-} //PropertyExtensionTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/PropertyNameTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/PropertyNameTypeImpl.java
deleted file mode 100644
index 76ecad7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/PropertyNameTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.PropertyNameType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Property Name Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyNameTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyNameTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PropertyNameTypeImpl extends EObjectImpl implements PropertyNameType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PropertyNameTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.PROPERTY_NAME_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.PROPERTY_NAME_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.PROPERTY_NAME_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.PROPERTY_NAME_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.PROPERTY_NAME_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.PROPERTY_NAME_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.PROPERTY_NAME_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.PROPERTY_NAME_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.PROPERTY_NAME_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.PROPERTY_NAME_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.PROPERTY_NAME_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //PropertyNameTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/PropertyResolverTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/PropertyResolverTypeImpl.java
deleted file mode 100644
index 954da7d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/PropertyResolverTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.PropertyResolverType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Property Resolver Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyResolverTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyResolverTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PropertyResolverTypeImpl extends EObjectImpl implements PropertyResolverType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PropertyResolverTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.PROPERTY_RESOLVER_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.PROPERTY_RESOLVER_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.PROPERTY_RESOLVER_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.PROPERTY_RESOLVER_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.PROPERTY_RESOLVER_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.PROPERTY_RESOLVER_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.PROPERTY_RESOLVER_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.PROPERTY_RESOLVER_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.PROPERTY_RESOLVER_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.PROPERTY_RESOLVER_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.PROPERTY_RESOLVER_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //PropertyResolverTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/PropertyTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/PropertyTypeImpl.java
deleted file mode 100644
index a1ace9c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/PropertyTypeImpl.java
+++ /dev/null
@@ -1,617 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.DefaultValueType;
-import org.eclipse.jst.jsf.facesconfig.emf.DescriptionType;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.IconType;
-import org.eclipse.jst.jsf.facesconfig.emf.PropertyClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.PropertyExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.PropertyNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.PropertyType;
-import org.eclipse.jst.jsf.facesconfig.emf.SuggestedValueType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Property Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyTypeImpl#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyTypeImpl#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyTypeImpl#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyTypeImpl#getPropertyName <em>Property Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyTypeImpl#getPropertyClass <em>Property Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyTypeImpl#getDefaultValue <em>Default Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyTypeImpl#getSuggestedValue <em>Suggested Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyTypeImpl#getPropertyExtension <em>Property Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.PropertyTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PropertyTypeImpl extends EObjectImpl implements PropertyType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getDescription() <em>Description</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDescription()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList description;
-
-    /**
-	 * The cached value of the '{@link #getDisplayName() <em>Display Name</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDisplayName()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList displayName;
-
-    /**
-	 * The cached value of the '{@link #getIcon() <em>Icon</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getIcon()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList icon;
-
-    /**
-	 * The cached value of the '{@link #getPropertyName() <em>Property Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getPropertyName()
-	 * @generated
-	 * @ordered
-	 */
-	protected PropertyNameType propertyName;
-
-    /**
-	 * The cached value of the '{@link #getPropertyClass() <em>Property Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getPropertyClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected PropertyClassType propertyClass;
-
-    /**
-	 * The cached value of the '{@link #getDefaultValue() <em>Default Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDefaultValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected DefaultValueType defaultValue;
-
-    /**
-	 * The cached value of the '{@link #getSuggestedValue() <em>Suggested Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getSuggestedValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected SuggestedValueType suggestedValue;
-
-    /**
-	 * The cached value of the '{@link #getPropertyExtension() <em>Property Extension</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getPropertyExtension()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList propertyExtension;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected PropertyTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.PROPERTY_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDescription() {
-		if (description == null) {
-			description = new EObjectContainmentEList(DescriptionType.class, this, FacesConfigPackage.PROPERTY_TYPE__DESCRIPTION);
-		}
-		return description;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDisplayName() {
-		if (displayName == null) {
-			displayName = new EObjectContainmentEList(DisplayNameType.class, this, FacesConfigPackage.PROPERTY_TYPE__DISPLAY_NAME);
-		}
-		return displayName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getIcon() {
-		if (icon == null) {
-			icon = new EObjectContainmentEList(IconType.class, this, FacesConfigPackage.PROPERTY_TYPE__ICON);
-		}
-		return icon;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PropertyNameType getPropertyName() {
-		return propertyName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newPropertyName 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetPropertyName(PropertyNameType newPropertyName, NotificationChain msgs) {
-		PropertyNameType oldPropertyName = propertyName;
-		propertyName = newPropertyName;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.PROPERTY_TYPE__PROPERTY_NAME, oldPropertyName, newPropertyName);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setPropertyName(PropertyNameType newPropertyName) {
-		if (newPropertyName != propertyName) {
-			NotificationChain msgs = null;
-			if (propertyName != null)
-				msgs = ((InternalEObject)propertyName).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.PROPERTY_TYPE__PROPERTY_NAME, null, msgs);
-			if (newPropertyName != null)
-				msgs = ((InternalEObject)newPropertyName).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.PROPERTY_TYPE__PROPERTY_NAME, null, msgs);
-			msgs = basicSetPropertyName(newPropertyName, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.PROPERTY_TYPE__PROPERTY_NAME, newPropertyName, newPropertyName));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public PropertyClassType getPropertyClass() {
-		return propertyClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newPropertyClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetPropertyClass(PropertyClassType newPropertyClass, NotificationChain msgs) {
-		PropertyClassType oldPropertyClass = propertyClass;
-		propertyClass = newPropertyClass;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.PROPERTY_TYPE__PROPERTY_CLASS, oldPropertyClass, newPropertyClass);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setPropertyClass(PropertyClassType newPropertyClass) {
-		if (newPropertyClass != propertyClass) {
-			NotificationChain msgs = null;
-			if (propertyClass != null)
-				msgs = ((InternalEObject)propertyClass).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.PROPERTY_TYPE__PROPERTY_CLASS, null, msgs);
-			if (newPropertyClass != null)
-				msgs = ((InternalEObject)newPropertyClass).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.PROPERTY_TYPE__PROPERTY_CLASS, null, msgs);
-			msgs = basicSetPropertyClass(newPropertyClass, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.PROPERTY_TYPE__PROPERTY_CLASS, newPropertyClass, newPropertyClass));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DefaultValueType getDefaultValue() {
-		return defaultValue;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newDefaultValue 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetDefaultValue(DefaultValueType newDefaultValue, NotificationChain msgs) {
-		DefaultValueType oldDefaultValue = defaultValue;
-		defaultValue = newDefaultValue;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.PROPERTY_TYPE__DEFAULT_VALUE, oldDefaultValue, newDefaultValue);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setDefaultValue(DefaultValueType newDefaultValue) {
-		if (newDefaultValue != defaultValue) {
-			NotificationChain msgs = null;
-			if (defaultValue != null)
-				msgs = ((InternalEObject)defaultValue).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.PROPERTY_TYPE__DEFAULT_VALUE, null, msgs);
-			if (newDefaultValue != null)
-				msgs = ((InternalEObject)newDefaultValue).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.PROPERTY_TYPE__DEFAULT_VALUE, null, msgs);
-			msgs = basicSetDefaultValue(newDefaultValue, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.PROPERTY_TYPE__DEFAULT_VALUE, newDefaultValue, newDefaultValue));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SuggestedValueType getSuggestedValue() {
-		return suggestedValue;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newSuggestedValue 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetSuggestedValue(SuggestedValueType newSuggestedValue, NotificationChain msgs) {
-		SuggestedValueType oldSuggestedValue = suggestedValue;
-		suggestedValue = newSuggestedValue;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.PROPERTY_TYPE__SUGGESTED_VALUE, oldSuggestedValue, newSuggestedValue);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setSuggestedValue(SuggestedValueType newSuggestedValue) {
-		if (newSuggestedValue != suggestedValue) {
-			NotificationChain msgs = null;
-			if (suggestedValue != null)
-				msgs = ((InternalEObject)suggestedValue).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.PROPERTY_TYPE__SUGGESTED_VALUE, null, msgs);
-			if (newSuggestedValue != null)
-				msgs = ((InternalEObject)newSuggestedValue).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.PROPERTY_TYPE__SUGGESTED_VALUE, null, msgs);
-			msgs = basicSetSuggestedValue(newSuggestedValue, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.PROPERTY_TYPE__SUGGESTED_VALUE, newSuggestedValue, newSuggestedValue));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getPropertyExtension() {
-		if (propertyExtension == null) {
-			propertyExtension = new EObjectContainmentEList(PropertyExtensionType.class, this, FacesConfigPackage.PROPERTY_TYPE__PROPERTY_EXTENSION);
-		}
-		return propertyExtension;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.PROPERTY_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.PROPERTY_TYPE__DESCRIPTION:
-				return ((InternalEList)getDescription()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.PROPERTY_TYPE__DISPLAY_NAME:
-				return ((InternalEList)getDisplayName()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.PROPERTY_TYPE__ICON:
-				return ((InternalEList)getIcon()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.PROPERTY_TYPE__PROPERTY_NAME:
-				return basicSetPropertyName(null, msgs);
-			case FacesConfigPackage.PROPERTY_TYPE__PROPERTY_CLASS:
-				return basicSetPropertyClass(null, msgs);
-			case FacesConfigPackage.PROPERTY_TYPE__DEFAULT_VALUE:
-				return basicSetDefaultValue(null, msgs);
-			case FacesConfigPackage.PROPERTY_TYPE__SUGGESTED_VALUE:
-				return basicSetSuggestedValue(null, msgs);
-			case FacesConfigPackage.PROPERTY_TYPE__PROPERTY_EXTENSION:
-				return ((InternalEList)getPropertyExtension()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.PROPERTY_TYPE__DESCRIPTION:
-				return getDescription();
-			case FacesConfigPackage.PROPERTY_TYPE__DISPLAY_NAME:
-				return getDisplayName();
-			case FacesConfigPackage.PROPERTY_TYPE__ICON:
-				return getIcon();
-			case FacesConfigPackage.PROPERTY_TYPE__PROPERTY_NAME:
-				return getPropertyName();
-			case FacesConfigPackage.PROPERTY_TYPE__PROPERTY_CLASS:
-				return getPropertyClass();
-			case FacesConfigPackage.PROPERTY_TYPE__DEFAULT_VALUE:
-				return getDefaultValue();
-			case FacesConfigPackage.PROPERTY_TYPE__SUGGESTED_VALUE:
-				return getSuggestedValue();
-			case FacesConfigPackage.PROPERTY_TYPE__PROPERTY_EXTENSION:
-				return getPropertyExtension();
-			case FacesConfigPackage.PROPERTY_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.PROPERTY_TYPE__DESCRIPTION:
-				getDescription().clear();
-				getDescription().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.PROPERTY_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				getDisplayName().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.PROPERTY_TYPE__ICON:
-				getIcon().clear();
-				getIcon().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.PROPERTY_TYPE__PROPERTY_NAME:
-				setPropertyName((PropertyNameType)newValue);
-				return;
-			case FacesConfigPackage.PROPERTY_TYPE__PROPERTY_CLASS:
-				setPropertyClass((PropertyClassType)newValue);
-				return;
-			case FacesConfigPackage.PROPERTY_TYPE__DEFAULT_VALUE:
-				setDefaultValue((DefaultValueType)newValue);
-				return;
-			case FacesConfigPackage.PROPERTY_TYPE__SUGGESTED_VALUE:
-				setSuggestedValue((SuggestedValueType)newValue);
-				return;
-			case FacesConfigPackage.PROPERTY_TYPE__PROPERTY_EXTENSION:
-				getPropertyExtension().clear();
-				getPropertyExtension().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.PROPERTY_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.PROPERTY_TYPE__DESCRIPTION:
-				getDescription().clear();
-				return;
-			case FacesConfigPackage.PROPERTY_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				return;
-			case FacesConfigPackage.PROPERTY_TYPE__ICON:
-				getIcon().clear();
-				return;
-			case FacesConfigPackage.PROPERTY_TYPE__PROPERTY_NAME:
-				setPropertyName((PropertyNameType)null);
-				return;
-			case FacesConfigPackage.PROPERTY_TYPE__PROPERTY_CLASS:
-				setPropertyClass((PropertyClassType)null);
-				return;
-			case FacesConfigPackage.PROPERTY_TYPE__DEFAULT_VALUE:
-				setDefaultValue((DefaultValueType)null);
-				return;
-			case FacesConfigPackage.PROPERTY_TYPE__SUGGESTED_VALUE:
-				setSuggestedValue((SuggestedValueType)null);
-				return;
-			case FacesConfigPackage.PROPERTY_TYPE__PROPERTY_EXTENSION:
-				getPropertyExtension().clear();
-				return;
-			case FacesConfigPackage.PROPERTY_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.PROPERTY_TYPE__DESCRIPTION:
-				return description != null && !description.isEmpty();
-			case FacesConfigPackage.PROPERTY_TYPE__DISPLAY_NAME:
-				return displayName != null && !displayName.isEmpty();
-			case FacesConfigPackage.PROPERTY_TYPE__ICON:
-				return icon != null && !icon.isEmpty();
-			case FacesConfigPackage.PROPERTY_TYPE__PROPERTY_NAME:
-				return propertyName != null;
-			case FacesConfigPackage.PROPERTY_TYPE__PROPERTY_CLASS:
-				return propertyClass != null;
-			case FacesConfigPackage.PROPERTY_TYPE__DEFAULT_VALUE:
-				return defaultValue != null;
-			case FacesConfigPackage.PROPERTY_TYPE__SUGGESTED_VALUE:
-				return suggestedValue != null;
-			case FacesConfigPackage.PROPERTY_TYPE__PROPERTY_EXTENSION:
-				return propertyExtension != null && !propertyExtension.isEmpty();
-			case FacesConfigPackage.PROPERTY_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //PropertyTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RedirectTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RedirectTypeImpl.java
deleted file mode 100644
index dc35c6f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RedirectTypeImpl.java
+++ /dev/null
@@ -1,280 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.RedirectType;
-import org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Redirect Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RedirectTypeImpl#getViewParam <em>View Param</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RedirectTypeImpl#getId <em>Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RedirectTypeImpl#isIncludeViewParams <em>Include View Params</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class RedirectTypeImpl extends EObjectImpl implements RedirectType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getViewParam() <em>View Param</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getViewParam()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList viewParam;
-
-				/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #isIncludeViewParams() <em>Include View Params</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isIncludeViewParams()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final boolean INCLUDE_VIEW_PARAMS_EDEFAULT = false;
-
-				/**
-	 * The cached value of the '{@link #isIncludeViewParams() <em>Include View Params</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isIncludeViewParams()
-	 * @generated
-	 * @ordered
-	 */
-	protected boolean includeViewParams = INCLUDE_VIEW_PARAMS_EDEFAULT;
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected RedirectTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.REDIRECT_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getViewParam() {
-		if (viewParam == null) {
-			viewParam = new EObjectContainmentEList(RedirectViewParamType.class, this, FacesConfigPackage.REDIRECT_TYPE__VIEW_PARAM);
-		}
-		return viewParam;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.REDIRECT_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isIncludeViewParams() {
-		return includeViewParams;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setIncludeViewParams(boolean newIncludeViewParams) {
-		boolean oldIncludeViewParams = includeViewParams;
-		includeViewParams = newIncludeViewParams;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.REDIRECT_TYPE__INCLUDE_VIEW_PARAMS, oldIncludeViewParams, includeViewParams));
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.REDIRECT_TYPE__VIEW_PARAM:
-				return ((InternalEList)getViewParam()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.REDIRECT_TYPE__VIEW_PARAM:
-				return getViewParam();
-			case FacesConfigPackage.REDIRECT_TYPE__ID:
-				return getId();
-			case FacesConfigPackage.REDIRECT_TYPE__INCLUDE_VIEW_PARAMS:
-				return isIncludeViewParams() ? Boolean.TRUE : Boolean.FALSE;
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.REDIRECT_TYPE__VIEW_PARAM:
-				getViewParam().clear();
-				getViewParam().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.REDIRECT_TYPE__ID:
-				setId((String)newValue);
-				return;
-			case FacesConfigPackage.REDIRECT_TYPE__INCLUDE_VIEW_PARAMS:
-				setIncludeViewParams(((Boolean)newValue).booleanValue());
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.REDIRECT_TYPE__VIEW_PARAM:
-				getViewParam().clear();
-				return;
-			case FacesConfigPackage.REDIRECT_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-			case FacesConfigPackage.REDIRECT_TYPE__INCLUDE_VIEW_PARAMS:
-				setIncludeViewParams(INCLUDE_VIEW_PARAMS_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.REDIRECT_TYPE__VIEW_PARAM:
-				return viewParam != null && !viewParam.isEmpty();
-			case FacesConfigPackage.REDIRECT_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-			case FacesConfigPackage.REDIRECT_TYPE__INCLUDE_VIEW_PARAMS:
-				return includeViewParams != INCLUDE_VIEW_PARAMS_EDEFAULT;
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(", includeViewParams: "); //$NON-NLS-1$
-		result.append(includeViewParams);
-		result.append(')');
-		return result.toString();
-	}
-
-} //RedirectTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RedirectViewParamTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RedirectViewParamTypeImpl.java
deleted file mode 100644
index ac34d57..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RedirectViewParamTypeImpl.java
+++ /dev/null
@@ -1,323 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.NameType;
-import org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType;
-import org.eclipse.jst.jsf.facesconfig.emf.ValueType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Redirect View Param Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RedirectViewParamTypeImpl#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RedirectViewParamTypeImpl#getValue <em>Value</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RedirectViewParamTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class RedirectViewParamTypeImpl extends EObjectImpl implements RedirectViewParamType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The cached value of the '{@link #getName() <em>Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getName()
-	 * @generated
-	 * @ordered
-	 */
-	protected NameType name;
-
-	/**
-	 * The cached value of the '{@link #getValue() <em>Value</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getValue()
-	 * @generated
-	 * @ordered
-	 */
-	protected ValueType value;
-
-	/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected RedirectViewParamTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.REDIRECT_VIEW_PARAM_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NameType getName() {
-		return name;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * @param newName 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetName(NameType newName, NotificationChain msgs) {
-		NameType oldName = name;
-		name = newName;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__NAME, oldName, newName);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setName(NameType newName) {
-		if (newName != name) {
-			NotificationChain msgs = null;
-			if (name != null)
-				msgs = ((InternalEObject)name).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__NAME, null, msgs);
-			if (newName != null)
-				msgs = ((InternalEObject)newName).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__NAME, null, msgs);
-			msgs = basicSetName(newName, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__NAME, newName, newName));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValueType getValue() {
-		return value;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * @param newValue 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetValue(ValueType newValue, NotificationChain msgs) {
-		ValueType oldValue = value;
-		value = newValue;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__VALUE, oldValue, newValue);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setValue(ValueType newValue) {
-		if (newValue != value) {
-			NotificationChain msgs = null;
-			if (value != null)
-				msgs = ((InternalEObject)value).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__VALUE, null, msgs);
-			if (newValue != null)
-				msgs = ((InternalEObject)newValue).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__VALUE, null, msgs);
-			msgs = basicSetValue(newValue, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__VALUE, newValue, newValue));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__ID, oldId, id));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__NAME:
-				return basicSetName(null, msgs);
-			case FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__VALUE:
-				return basicSetValue(null, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__NAME:
-				return getName();
-			case FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__VALUE:
-				return getValue();
-			case FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__NAME:
-				setName((NameType)newValue);
-				return;
-			case FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__VALUE:
-				setValue((ValueType)newValue);
-				return;
-			case FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__NAME:
-				setName((NameType)null);
-				return;
-			case FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__VALUE:
-				setValue((ValueType)null);
-				return;
-			case FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__NAME:
-				return name != null;
-			case FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__VALUE:
-				return value != null;
-			case FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //RedirectViewParamTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ReferencedBeanClassTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ReferencedBeanClassTypeImpl.java
deleted file mode 100644
index 8689119..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ReferencedBeanClassTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanClassType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Referenced Bean Class Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanClassTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanClassTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ReferencedBeanClassTypeImpl extends EObjectImpl implements ReferencedBeanClassType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ReferencedBeanClassTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.REFERENCED_BEAN_CLASS_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.REFERENCED_BEAN_CLASS_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.REFERENCED_BEAN_CLASS_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.REFERENCED_BEAN_CLASS_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.REFERENCED_BEAN_CLASS_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.REFERENCED_BEAN_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.REFERENCED_BEAN_CLASS_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.REFERENCED_BEAN_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.REFERENCED_BEAN_CLASS_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.REFERENCED_BEAN_CLASS_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.REFERENCED_BEAN_CLASS_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ReferencedBeanClassTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ReferencedBeanNameTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ReferencedBeanNameTypeImpl.java
deleted file mode 100644
index d0b1911..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ReferencedBeanNameTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanNameType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Referenced Bean Name Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanNameTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanNameTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ReferencedBeanNameTypeImpl extends EObjectImpl implements ReferencedBeanNameType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ReferencedBeanNameTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.REFERENCED_BEAN_NAME_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.REFERENCED_BEAN_NAME_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.REFERENCED_BEAN_NAME_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.REFERENCED_BEAN_NAME_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.REFERENCED_BEAN_NAME_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.REFERENCED_BEAN_NAME_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.REFERENCED_BEAN_NAME_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.REFERENCED_BEAN_NAME_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.REFERENCED_BEAN_NAME_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.REFERENCED_BEAN_NAME_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.REFERENCED_BEAN_NAME_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ReferencedBeanNameTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ReferencedBeanTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ReferencedBeanTypeImpl.java
deleted file mode 100644
index cb35f50..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ReferencedBeanTypeImpl.java
+++ /dev/null
@@ -1,440 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.DescriptionType;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.IconType;
-import org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Referenced Bean Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanTypeImpl#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanTypeImpl#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanTypeImpl#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanTypeImpl#getReferencedBeanName <em>Referenced Bean Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanTypeImpl#getReferencedBeanClass <em>Referenced Bean Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ReferencedBeanTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ReferencedBeanTypeImpl extends EObjectImpl implements ReferencedBeanType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getDescription() <em>Description</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDescription()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList description;
-
-    /**
-	 * The cached value of the '{@link #getDisplayName() <em>Display Name</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDisplayName()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList displayName;
-
-    /**
-	 * The cached value of the '{@link #getIcon() <em>Icon</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getIcon()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList icon;
-
-    /**
-	 * The cached value of the '{@link #getReferencedBeanName() <em>Referenced Bean Name</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getReferencedBeanName()
-	 * @generated
-	 * @ordered
-	 */
-	protected ReferencedBeanNameType referencedBeanName;
-
-    /**
-	 * The cached value of the '{@link #getReferencedBeanClass() <em>Referenced Bean Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getReferencedBeanClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected ReferencedBeanClassType referencedBeanClass;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ReferencedBeanTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.REFERENCED_BEAN_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDescription() {
-		if (description == null) {
-			description = new EObjectContainmentEList(DescriptionType.class, this, FacesConfigPackage.REFERENCED_BEAN_TYPE__DESCRIPTION);
-		}
-		return description;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDisplayName() {
-		if (displayName == null) {
-			displayName = new EObjectContainmentEList(DisplayNameType.class, this, FacesConfigPackage.REFERENCED_BEAN_TYPE__DISPLAY_NAME);
-		}
-		return displayName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getIcon() {
-		if (icon == null) {
-			icon = new EObjectContainmentEList(IconType.class, this, FacesConfigPackage.REFERENCED_BEAN_TYPE__ICON);
-		}
-		return icon;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ReferencedBeanNameType getReferencedBeanName() {
-		return referencedBeanName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newReferencedBeanName 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetReferencedBeanName(ReferencedBeanNameType newReferencedBeanName, NotificationChain msgs) {
-		ReferencedBeanNameType oldReferencedBeanName = referencedBeanName;
-		referencedBeanName = newReferencedBeanName;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_NAME, oldReferencedBeanName, newReferencedBeanName);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setReferencedBeanName(ReferencedBeanNameType newReferencedBeanName) {
-		if (newReferencedBeanName != referencedBeanName) {
-			NotificationChain msgs = null;
-			if (referencedBeanName != null)
-				msgs = ((InternalEObject)referencedBeanName).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_NAME, null, msgs);
-			if (newReferencedBeanName != null)
-				msgs = ((InternalEObject)newReferencedBeanName).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_NAME, null, msgs);
-			msgs = basicSetReferencedBeanName(newReferencedBeanName, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_NAME, newReferencedBeanName, newReferencedBeanName));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ReferencedBeanClassType getReferencedBeanClass() {
-		return referencedBeanClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newReferencedBeanClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetReferencedBeanClass(ReferencedBeanClassType newReferencedBeanClass, NotificationChain msgs) {
-		ReferencedBeanClassType oldReferencedBeanClass = referencedBeanClass;
-		referencedBeanClass = newReferencedBeanClass;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_CLASS, oldReferencedBeanClass, newReferencedBeanClass);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setReferencedBeanClass(ReferencedBeanClassType newReferencedBeanClass) {
-		if (newReferencedBeanClass != referencedBeanClass) {
-			NotificationChain msgs = null;
-			if (referencedBeanClass != null)
-				msgs = ((InternalEObject)referencedBeanClass).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_CLASS, null, msgs);
-			if (newReferencedBeanClass != null)
-				msgs = ((InternalEObject)newReferencedBeanClass).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_CLASS, null, msgs);
-			msgs = basicSetReferencedBeanClass(newReferencedBeanClass, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_CLASS, newReferencedBeanClass, newReferencedBeanClass));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.REFERENCED_BEAN_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__DESCRIPTION:
-				return ((InternalEList)getDescription()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__DISPLAY_NAME:
-				return ((InternalEList)getDisplayName()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__ICON:
-				return ((InternalEList)getIcon()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_NAME:
-				return basicSetReferencedBeanName(null, msgs);
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_CLASS:
-				return basicSetReferencedBeanClass(null, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__DESCRIPTION:
-				return getDescription();
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__DISPLAY_NAME:
-				return getDisplayName();
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__ICON:
-				return getIcon();
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_NAME:
-				return getReferencedBeanName();
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_CLASS:
-				return getReferencedBeanClass();
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__DESCRIPTION:
-				getDescription().clear();
-				getDescription().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				getDisplayName().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__ICON:
-				getIcon().clear();
-				getIcon().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_NAME:
-				setReferencedBeanName((ReferencedBeanNameType)newValue);
-				return;
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_CLASS:
-				setReferencedBeanClass((ReferencedBeanClassType)newValue);
-				return;
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__DESCRIPTION:
-				getDescription().clear();
-				return;
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				return;
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__ICON:
-				getIcon().clear();
-				return;
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_NAME:
-				setReferencedBeanName((ReferencedBeanNameType)null);
-				return;
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_CLASS:
-				setReferencedBeanClass((ReferencedBeanClassType)null);
-				return;
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__DESCRIPTION:
-				return description != null && !description.isEmpty();
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__DISPLAY_NAME:
-				return displayName != null && !displayName.isEmpty();
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__ICON:
-				return icon != null && !icon.isEmpty();
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_NAME:
-				return referencedBeanName != null;
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__REFERENCED_BEAN_CLASS:
-				return referencedBeanClass != null;
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ReferencedBeanTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RenderKitClassTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RenderKitClassTypeImpl.java
deleted file mode 100644
index d908748..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RenderKitClassTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.RenderKitClassType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Render Kit Class Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitClassTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitClassTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class RenderKitClassTypeImpl extends EObjectImpl implements RenderKitClassType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected RenderKitClassTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.RENDER_KIT_CLASS_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDER_KIT_CLASS_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDER_KIT_CLASS_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDER_KIT_CLASS_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.RENDER_KIT_CLASS_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDER_KIT_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.RENDER_KIT_CLASS_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDER_KIT_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.RENDER_KIT_CLASS_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDER_KIT_CLASS_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.RENDER_KIT_CLASS_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //RenderKitClassTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RenderKitExtensionTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RenderKitExtensionTypeImpl.java
deleted file mode 100644
index e0fcbc3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RenderKitExtensionTypeImpl.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.RenderKitExtensionType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Render Kit Extension Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * </p>
- *
- * @generated
- */
-public class RenderKitExtensionTypeImpl extends ExtensionTypeImpl implements RenderKitExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    @SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected RenderKitExtensionTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.RENDER_KIT_EXTENSION_TYPE;
-	}
-
-} //RenderKitExtensionTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RenderKitFactoryTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RenderKitFactoryTypeImpl.java
deleted file mode 100644
index d2a2804..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RenderKitFactoryTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.RenderKitFactoryType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Render Kit Factory Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitFactoryTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitFactoryTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class RenderKitFactoryTypeImpl extends EObjectImpl implements RenderKitFactoryType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected RenderKitFactoryTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.RENDER_KIT_FACTORY_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDER_KIT_FACTORY_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDER_KIT_FACTORY_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDER_KIT_FACTORY_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.RENDER_KIT_FACTORY_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDER_KIT_FACTORY_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.RENDER_KIT_FACTORY_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDER_KIT_FACTORY_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.RENDER_KIT_FACTORY_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDER_KIT_FACTORY_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.RENDER_KIT_FACTORY_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //RenderKitFactoryTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RenderKitIdTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RenderKitIdTypeImpl.java
deleted file mode 100644
index 5f9c6cd..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RenderKitIdTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.RenderKitIdType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Render Kit Id Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitIdTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitIdTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class RenderKitIdTypeImpl extends EObjectImpl implements RenderKitIdType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected RenderKitIdTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.RENDER_KIT_ID_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDER_KIT_ID_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDER_KIT_ID_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDER_KIT_ID_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.RENDER_KIT_ID_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDER_KIT_ID_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.RENDER_KIT_ID_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDER_KIT_ID_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.RENDER_KIT_ID_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDER_KIT_ID_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.RENDER_KIT_ID_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //RenderKitIdTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RenderKitTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RenderKitTypeImpl.java
deleted file mode 100644
index 55d5742..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RenderKitTypeImpl.java
+++ /dev/null
@@ -1,551 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererType;
-import org.eclipse.jst.jsf.facesconfig.emf.DescriptionType;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.IconType;
-import org.eclipse.jst.jsf.facesconfig.emf.RenderKitClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.RenderKitExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.RenderKitIdType;
-import org.eclipse.jst.jsf.facesconfig.emf.RenderKitType;
-import org.eclipse.jst.jsf.facesconfig.emf.RendererType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Render Kit Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitTypeImpl#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitTypeImpl#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitTypeImpl#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitTypeImpl#getRenderKitId <em>Render Kit Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitTypeImpl#getRenderKitClass <em>Render Kit Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitTypeImpl#getRenderer <em>Renderer</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitTypeImpl#getClientBehaviorRenderer <em>Client Behavior Renderer</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitTypeImpl#getRenderKitExtension <em>Render Kit Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RenderKitTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class RenderKitTypeImpl extends EObjectImpl implements RenderKitType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getDescription() <em>Description</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDescription()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList description;
-
-    /**
-	 * The cached value of the '{@link #getDisplayName() <em>Display Name</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDisplayName()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList displayName;
-
-    /**
-	 * The cached value of the '{@link #getIcon() <em>Icon</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getIcon()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList icon;
-
-    /**
-	 * The cached value of the '{@link #getRenderKitId() <em>Render Kit Id</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getRenderKitId()
-	 * @generated
-	 * @ordered
-	 */
-	protected RenderKitIdType renderKitId;
-
-    /**
-	 * The cached value of the '{@link #getRenderKitClass() <em>Render Kit Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getRenderKitClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected RenderKitClassType renderKitClass;
-
-    /**
-	 * The cached value of the '{@link #getRenderer() <em>Renderer</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getRenderer()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList renderer;
-
-    /**
-	 * The cached value of the '{@link #getClientBehaviorRenderer() <em>Client Behavior Renderer</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getClientBehaviorRenderer()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList clientBehaviorRenderer;
-
-				/**
-	 * The cached value of the '{@link #getRenderKitExtension() <em>Render Kit Extension</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getRenderKitExtension()
-	 * @generated
-	 * @ordered
-	 */
-    protected EList renderKitExtension;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected RenderKitTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.RENDER_KIT_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDescription() {
-		if (description == null) {
-			description = new EObjectContainmentEList(DescriptionType.class, this, FacesConfigPackage.RENDER_KIT_TYPE__DESCRIPTION);
-		}
-		return description;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDisplayName() {
-		if (displayName == null) {
-			displayName = new EObjectContainmentEList(DisplayNameType.class, this, FacesConfigPackage.RENDER_KIT_TYPE__DISPLAY_NAME);
-		}
-		return displayName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getIcon() {
-		if (icon == null) {
-			icon = new EObjectContainmentEList(IconType.class, this, FacesConfigPackage.RENDER_KIT_TYPE__ICON);
-		}
-		return icon;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RenderKitIdType getRenderKitId() {
-		return renderKitId;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newRenderKitId 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetRenderKitId(RenderKitIdType newRenderKitId, NotificationChain msgs) {
-		RenderKitIdType oldRenderKitId = renderKitId;
-		renderKitId = newRenderKitId;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_ID, oldRenderKitId, newRenderKitId);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setRenderKitId(RenderKitIdType newRenderKitId) {
-		if (newRenderKitId != renderKitId) {
-			NotificationChain msgs = null;
-			if (renderKitId != null)
-				msgs = ((InternalEObject)renderKitId).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_ID, null, msgs);
-			if (newRenderKitId != null)
-				msgs = ((InternalEObject)newRenderKitId).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_ID, null, msgs);
-			msgs = basicSetRenderKitId(newRenderKitId, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_ID, newRenderKitId, newRenderKitId));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RenderKitClassType getRenderKitClass() {
-		return renderKitClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newRenderKitClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetRenderKitClass(RenderKitClassType newRenderKitClass, NotificationChain msgs) {
-		RenderKitClassType oldRenderKitClass = renderKitClass;
-		renderKitClass = newRenderKitClass;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_CLASS, oldRenderKitClass, newRenderKitClass);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setRenderKitClass(RenderKitClassType newRenderKitClass) {
-		if (newRenderKitClass != renderKitClass) {
-			NotificationChain msgs = null;
-			if (renderKitClass != null)
-				msgs = ((InternalEObject)renderKitClass).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_CLASS, null, msgs);
-			if (newRenderKitClass != null)
-				msgs = ((InternalEObject)newRenderKitClass).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_CLASS, null, msgs);
-			msgs = basicSetRenderKitClass(newRenderKitClass, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_CLASS, newRenderKitClass, newRenderKitClass));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getRenderer() {
-		if (renderer == null) {
-			renderer = new EObjectContainmentEList(RendererType.class, this, FacesConfigPackage.RENDER_KIT_TYPE__RENDERER);
-		}
-		return renderer;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getClientBehaviorRenderer() {
-		if (clientBehaviorRenderer == null) {
-			clientBehaviorRenderer = new EObjectContainmentEList(ClientBehaviorRendererType.class, this, FacesConfigPackage.RENDER_KIT_TYPE__CLIENT_BEHAVIOR_RENDERER);
-		}
-		return clientBehaviorRenderer;
-	}
-
-				/**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EList getRenderKitExtension() {
-		if (renderKitExtension == null) {
-			renderKitExtension = new EObjectContainmentEList(RenderKitExtensionType.class, this, FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_EXTENSION);
-		}
-		return renderKitExtension;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDER_KIT_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDER_KIT_TYPE__DESCRIPTION:
-				return ((InternalEList)getDescription()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.RENDER_KIT_TYPE__DISPLAY_NAME:
-				return ((InternalEList)getDisplayName()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.RENDER_KIT_TYPE__ICON:
-				return ((InternalEList)getIcon()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_ID:
-				return basicSetRenderKitId(null, msgs);
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_CLASS:
-				return basicSetRenderKitClass(null, msgs);
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDERER:
-				return ((InternalEList)getRenderer()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.RENDER_KIT_TYPE__CLIENT_BEHAVIOR_RENDERER:
-				return ((InternalEList)getClientBehaviorRenderer()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_EXTENSION:
-				return ((InternalEList)getRenderKitExtension()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDER_KIT_TYPE__DESCRIPTION:
-				return getDescription();
-			case FacesConfigPackage.RENDER_KIT_TYPE__DISPLAY_NAME:
-				return getDisplayName();
-			case FacesConfigPackage.RENDER_KIT_TYPE__ICON:
-				return getIcon();
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_ID:
-				return getRenderKitId();
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_CLASS:
-				return getRenderKitClass();
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDERER:
-				return getRenderer();
-			case FacesConfigPackage.RENDER_KIT_TYPE__CLIENT_BEHAVIOR_RENDERER:
-				return getClientBehaviorRenderer();
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_EXTENSION:
-				return getRenderKitExtension();
-			case FacesConfigPackage.RENDER_KIT_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDER_KIT_TYPE__DESCRIPTION:
-				getDescription().clear();
-				getDescription().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.RENDER_KIT_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				getDisplayName().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.RENDER_KIT_TYPE__ICON:
-				getIcon().clear();
-				getIcon().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_ID:
-				setRenderKitId((RenderKitIdType)newValue);
-				return;
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_CLASS:
-				setRenderKitClass((RenderKitClassType)newValue);
-				return;
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDERER:
-				getRenderer().clear();
-				getRenderer().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.RENDER_KIT_TYPE__CLIENT_BEHAVIOR_RENDERER:
-				getClientBehaviorRenderer().clear();
-				getClientBehaviorRenderer().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_EXTENSION:
-				getRenderKitExtension().clear();
-				getRenderKitExtension().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.RENDER_KIT_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDER_KIT_TYPE__DESCRIPTION:
-				getDescription().clear();
-				return;
-			case FacesConfigPackage.RENDER_KIT_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				return;
-			case FacesConfigPackage.RENDER_KIT_TYPE__ICON:
-				getIcon().clear();
-				return;
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_ID:
-				setRenderKitId((RenderKitIdType)null);
-				return;
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_CLASS:
-				setRenderKitClass((RenderKitClassType)null);
-				return;
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDERER:
-				getRenderer().clear();
-				return;
-			case FacesConfigPackage.RENDER_KIT_TYPE__CLIENT_BEHAVIOR_RENDERER:
-				getClientBehaviorRenderer().clear();
-				return;
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_EXTENSION:
-				getRenderKitExtension().clear();
-				return;
-			case FacesConfigPackage.RENDER_KIT_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDER_KIT_TYPE__DESCRIPTION:
-				return description != null && !description.isEmpty();
-			case FacesConfigPackage.RENDER_KIT_TYPE__DISPLAY_NAME:
-				return displayName != null && !displayName.isEmpty();
-			case FacesConfigPackage.RENDER_KIT_TYPE__ICON:
-				return icon != null && !icon.isEmpty();
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_ID:
-				return renderKitId != null;
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_CLASS:
-				return renderKitClass != null;
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDERER:
-				return renderer != null && !renderer.isEmpty();
-			case FacesConfigPackage.RENDER_KIT_TYPE__CLIENT_BEHAVIOR_RENDERER:
-				return clientBehaviorRenderer != null && !clientBehaviorRenderer.isEmpty();
-			case FacesConfigPackage.RENDER_KIT_TYPE__RENDER_KIT_EXTENSION:
-				return renderKitExtension != null && !renderKitExtension.isEmpty();
-			case FacesConfigPackage.RENDER_KIT_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //RenderKitTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RendererClassTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RendererClassTypeImpl.java
deleted file mode 100644
index 817f53d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RendererClassTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.RendererClassType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Renderer Class Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererClassTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererClassTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class RendererClassTypeImpl extends EObjectImpl implements RendererClassType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected RendererClassTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.RENDERER_CLASS_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDERER_CLASS_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDERER_CLASS_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDERER_CLASS_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.RENDERER_CLASS_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDERER_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.RENDERER_CLASS_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDERER_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.RENDERER_CLASS_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDERER_CLASS_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.RENDERER_CLASS_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //RendererClassTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RendererExtensionTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RendererExtensionTypeImpl.java
deleted file mode 100644
index f62d4ed..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RendererExtensionTypeImpl.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.RendererExtensionType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Renderer Extension Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * </p>
- *
- * @generated
- */
-public class RendererExtensionTypeImpl extends ExtensionTypeImpl implements RendererExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected RendererExtensionTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.RENDERER_EXTENSION_TYPE;
-	}
-
-} //RendererExtensionTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RendererTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RendererTypeImpl.java
deleted file mode 100644
index 60662d2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RendererTypeImpl.java
+++ /dev/null
@@ -1,621 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.AttributeType;
-import org.eclipse.jst.jsf.facesconfig.emf.ComponentFamilyType;
-import org.eclipse.jst.jsf.facesconfig.emf.DescriptionType;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.FacetType;
-import org.eclipse.jst.jsf.facesconfig.emf.IconType;
-import org.eclipse.jst.jsf.facesconfig.emf.RendererClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.RendererExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.RendererType;
-import org.eclipse.jst.jsf.facesconfig.emf.RendererTypeType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Renderer Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeImpl#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeImpl#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeImpl#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeImpl#getComponentFamily <em>Component Family</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeImpl#getRendererType <em>Renderer Type</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeImpl#getRendererClass <em>Renderer Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeImpl#getFacet <em>Facet</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeImpl#getAttribute <em>Attribute</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeImpl#getRendererExtension <em>Renderer Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class RendererTypeImpl extends EObjectImpl implements RendererType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getDescription() <em>Description</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDescription()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList description;
-
-    /**
-	 * The cached value of the '{@link #getDisplayName() <em>Display Name</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDisplayName()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList displayName;
-
-    /**
-	 * The cached value of the '{@link #getIcon() <em>Icon</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getIcon()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList icon;
-
-    /**
-	 * The cached value of the '{@link #getComponentFamily() <em>Component Family</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getComponentFamily()
-	 * @generated
-	 * @ordered
-	 */
-	protected ComponentFamilyType componentFamily;
-
-    /**
-	 * The cached value of the '{@link #getRendererType() <em>Renderer Type</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getRendererType()
-	 * @generated
-	 * @ordered
-	 */
-	protected RendererTypeType rendererType;
-
-    /**
-	 * The cached value of the '{@link #getRendererClass() <em>Renderer Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getRendererClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected RendererClassType rendererClass;
-
-    /**
-	 * The cached value of the '{@link #getFacet() <em>Facet</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getFacet()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList facet;
-
-    /**
-	 * The cached value of the '{@link #getAttribute() <em>Attribute</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getAttribute()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList attribute;
-
-    /**
-	 * The cached value of the '{@link #getRendererExtension() <em>Renderer Extension</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getRendererExtension()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList rendererExtension;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected RendererTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.RENDERER_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDescription() {
-		if (description == null) {
-			description = new EObjectContainmentEList(DescriptionType.class, this, FacesConfigPackage.RENDERER_TYPE__DESCRIPTION);
-		}
-		return description;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDisplayName() {
-		if (displayName == null) {
-			displayName = new EObjectContainmentEList(DisplayNameType.class, this, FacesConfigPackage.RENDERER_TYPE__DISPLAY_NAME);
-		}
-		return displayName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getIcon() {
-		if (icon == null) {
-			icon = new EObjectContainmentEList(IconType.class, this, FacesConfigPackage.RENDERER_TYPE__ICON);
-		}
-		return icon;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ComponentFamilyType getComponentFamily() {
-		return componentFamily;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newComponentFamily 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetComponentFamily(ComponentFamilyType newComponentFamily, NotificationChain msgs) {
-		ComponentFamilyType oldComponentFamily = componentFamily;
-		componentFamily = newComponentFamily;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDERER_TYPE__COMPONENT_FAMILY, oldComponentFamily, newComponentFamily);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setComponentFamily(ComponentFamilyType newComponentFamily) {
-		if (newComponentFamily != componentFamily) {
-			NotificationChain msgs = null;
-			if (componentFamily != null)
-				msgs = ((InternalEObject)componentFamily).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.RENDERER_TYPE__COMPONENT_FAMILY, null, msgs);
-			if (newComponentFamily != null)
-				msgs = ((InternalEObject)newComponentFamily).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.RENDERER_TYPE__COMPONENT_FAMILY, null, msgs);
-			msgs = basicSetComponentFamily(newComponentFamily, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDERER_TYPE__COMPONENT_FAMILY, newComponentFamily, newComponentFamily));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RendererTypeType getRendererType() {
-		return rendererType;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newRendererType 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetRendererType(RendererTypeType newRendererType, NotificationChain msgs) {
-		RendererTypeType oldRendererType = rendererType;
-		rendererType = newRendererType;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDERER_TYPE__RENDERER_TYPE, oldRendererType, newRendererType);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setRendererType(RendererTypeType newRendererType) {
-		if (newRendererType != rendererType) {
-			NotificationChain msgs = null;
-			if (rendererType != null)
-				msgs = ((InternalEObject)rendererType).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.RENDERER_TYPE__RENDERER_TYPE, null, msgs);
-			if (newRendererType != null)
-				msgs = ((InternalEObject)newRendererType).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.RENDERER_TYPE__RENDERER_TYPE, null, msgs);
-			msgs = basicSetRendererType(newRendererType, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDERER_TYPE__RENDERER_TYPE, newRendererType, newRendererType));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public RendererClassType getRendererClass() {
-		return rendererClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newRendererClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetRendererClass(RendererClassType newRendererClass, NotificationChain msgs) {
-		RendererClassType oldRendererClass = rendererClass;
-		rendererClass = newRendererClass;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDERER_TYPE__RENDERER_CLASS, oldRendererClass, newRendererClass);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setRendererClass(RendererClassType newRendererClass) {
-		if (newRendererClass != rendererClass) {
-			NotificationChain msgs = null;
-			if (rendererClass != null)
-				msgs = ((InternalEObject)rendererClass).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.RENDERER_TYPE__RENDERER_CLASS, null, msgs);
-			if (newRendererClass != null)
-				msgs = ((InternalEObject)newRendererClass).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.RENDERER_TYPE__RENDERER_CLASS, null, msgs);
-			msgs = basicSetRendererClass(newRendererClass, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDERER_TYPE__RENDERER_CLASS, newRendererClass, newRendererClass));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getFacet() {
-		if (facet == null) {
-			facet = new EObjectContainmentEList(FacetType.class, this, FacesConfigPackage.RENDERER_TYPE__FACET);
-		}
-		return facet;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getAttribute() {
-		if (attribute == null) {
-			attribute = new EObjectContainmentEList(AttributeType.class, this, FacesConfigPackage.RENDERER_TYPE__ATTRIBUTE);
-		}
-		return attribute;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getRendererExtension() {
-		if (rendererExtension == null) {
-			rendererExtension = new EObjectContainmentEList(RendererExtensionType.class, this, FacesConfigPackage.RENDERER_TYPE__RENDERER_EXTENSION);
-		}
-		return rendererExtension;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDERER_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDERER_TYPE__DESCRIPTION:
-				return ((InternalEList)getDescription()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.RENDERER_TYPE__DISPLAY_NAME:
-				return ((InternalEList)getDisplayName()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.RENDERER_TYPE__ICON:
-				return ((InternalEList)getIcon()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.RENDERER_TYPE__COMPONENT_FAMILY:
-				return basicSetComponentFamily(null, msgs);
-			case FacesConfigPackage.RENDERER_TYPE__RENDERER_TYPE:
-				return basicSetRendererType(null, msgs);
-			case FacesConfigPackage.RENDERER_TYPE__RENDERER_CLASS:
-				return basicSetRendererClass(null, msgs);
-			case FacesConfigPackage.RENDERER_TYPE__FACET:
-				return ((InternalEList)getFacet()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.RENDERER_TYPE__ATTRIBUTE:
-				return ((InternalEList)getAttribute()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.RENDERER_TYPE__RENDERER_EXTENSION:
-				return ((InternalEList)getRendererExtension()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDERER_TYPE__DESCRIPTION:
-				return getDescription();
-			case FacesConfigPackage.RENDERER_TYPE__DISPLAY_NAME:
-				return getDisplayName();
-			case FacesConfigPackage.RENDERER_TYPE__ICON:
-				return getIcon();
-			case FacesConfigPackage.RENDERER_TYPE__COMPONENT_FAMILY:
-				return getComponentFamily();
-			case FacesConfigPackage.RENDERER_TYPE__RENDERER_TYPE:
-				return getRendererType();
-			case FacesConfigPackage.RENDERER_TYPE__RENDERER_CLASS:
-				return getRendererClass();
-			case FacesConfigPackage.RENDERER_TYPE__FACET:
-				return getFacet();
-			case FacesConfigPackage.RENDERER_TYPE__ATTRIBUTE:
-				return getAttribute();
-			case FacesConfigPackage.RENDERER_TYPE__RENDERER_EXTENSION:
-				return getRendererExtension();
-			case FacesConfigPackage.RENDERER_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDERER_TYPE__DESCRIPTION:
-				getDescription().clear();
-				getDescription().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.RENDERER_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				getDisplayName().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.RENDERER_TYPE__ICON:
-				getIcon().clear();
-				getIcon().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.RENDERER_TYPE__COMPONENT_FAMILY:
-				setComponentFamily((ComponentFamilyType)newValue);
-				return;
-			case FacesConfigPackage.RENDERER_TYPE__RENDERER_TYPE:
-				setRendererType((RendererTypeType)newValue);
-				return;
-			case FacesConfigPackage.RENDERER_TYPE__RENDERER_CLASS:
-				setRendererClass((RendererClassType)newValue);
-				return;
-			case FacesConfigPackage.RENDERER_TYPE__FACET:
-				getFacet().clear();
-				getFacet().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.RENDERER_TYPE__ATTRIBUTE:
-				getAttribute().clear();
-				getAttribute().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.RENDERER_TYPE__RENDERER_EXTENSION:
-				getRendererExtension().clear();
-				getRendererExtension().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.RENDERER_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDERER_TYPE__DESCRIPTION:
-				getDescription().clear();
-				return;
-			case FacesConfigPackage.RENDERER_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				return;
-			case FacesConfigPackage.RENDERER_TYPE__ICON:
-				getIcon().clear();
-				return;
-			case FacesConfigPackage.RENDERER_TYPE__COMPONENT_FAMILY:
-				setComponentFamily((ComponentFamilyType)null);
-				return;
-			case FacesConfigPackage.RENDERER_TYPE__RENDERER_TYPE:
-				setRendererType((RendererTypeType)null);
-				return;
-			case FacesConfigPackage.RENDERER_TYPE__RENDERER_CLASS:
-				setRendererClass((RendererClassType)null);
-				return;
-			case FacesConfigPackage.RENDERER_TYPE__FACET:
-				getFacet().clear();
-				return;
-			case FacesConfigPackage.RENDERER_TYPE__ATTRIBUTE:
-				getAttribute().clear();
-				return;
-			case FacesConfigPackage.RENDERER_TYPE__RENDERER_EXTENSION:
-				getRendererExtension().clear();
-				return;
-			case FacesConfigPackage.RENDERER_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDERER_TYPE__DESCRIPTION:
-				return description != null && !description.isEmpty();
-			case FacesConfigPackage.RENDERER_TYPE__DISPLAY_NAME:
-				return displayName != null && !displayName.isEmpty();
-			case FacesConfigPackage.RENDERER_TYPE__ICON:
-				return icon != null && !icon.isEmpty();
-			case FacesConfigPackage.RENDERER_TYPE__COMPONENT_FAMILY:
-				return componentFamily != null;
-			case FacesConfigPackage.RENDERER_TYPE__RENDERER_TYPE:
-				return rendererType != null;
-			case FacesConfigPackage.RENDERER_TYPE__RENDERER_CLASS:
-				return rendererClass != null;
-			case FacesConfigPackage.RENDERER_TYPE__FACET:
-				return facet != null && !facet.isEmpty();
-			case FacesConfigPackage.RENDERER_TYPE__ATTRIBUTE:
-				return attribute != null && !attribute.isEmpty();
-			case FacesConfigPackage.RENDERER_TYPE__RENDERER_EXTENSION:
-				return rendererExtension != null && !rendererExtension.isEmpty();
-			case FacesConfigPackage.RENDERER_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //RendererTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RendererTypeTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RendererTypeTypeImpl.java
deleted file mode 100644
index 115a166..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/RendererTypeTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.RendererTypeType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Renderer Type Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.RendererTypeTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class RendererTypeTypeImpl extends EObjectImpl implements RendererTypeType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected RendererTypeTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.RENDERER_TYPE_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDERER_TYPE_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RENDERER_TYPE_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDERER_TYPE_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.RENDERER_TYPE_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDERER_TYPE_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.RENDERER_TYPE_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDERER_TYPE_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.RENDERER_TYPE_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.RENDERER_TYPE_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.RENDERER_TYPE_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //RendererTypeTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ResourceBundleTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ResourceBundleTypeImpl.java
deleted file mode 100644
index 78418e0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ResourceBundleTypeImpl.java
+++ /dev/null
@@ -1,423 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.BaseNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.DescriptionType;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.IconType;
-import org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType;
-import org.eclipse.jst.jsf.facesconfig.emf.VarType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Resource Bundle Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ResourceBundleTypeImpl#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ResourceBundleTypeImpl#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ResourceBundleTypeImpl#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ResourceBundleTypeImpl#getBaseName <em>Base Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ResourceBundleTypeImpl#getVar <em>Var</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ResourceBundleTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ResourceBundleTypeImpl extends EObjectImpl implements ResourceBundleType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getDescription() <em>Description</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getDescription()
-	 * @generated
-	 * @ordered
-	 */
-    protected EList description;
-
-    /**
-	 * The cached value of the '{@link #getDisplayName() <em>Display Name</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getDisplayName()
-	 * @generated
-	 * @ordered
-	 */
-    protected EList displayName;
-
-    /**
-	 * The cached value of the '{@link #getIcon() <em>Icon</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getIcon()
-	 * @generated
-	 * @ordered
-	 */
-    protected EList icon;
-
-    /**
-	 * The cached value of the '{@link #getBaseName() <em>Base Name</em>}' reference.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getBaseName()
-	 * @generated
-	 * @ordered
-	 */
-    protected BaseNameType baseName;
-
-    /**
-	 * The cached value of the '{@link #getVar() <em>Var</em>}' reference.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getVar()
-	 * @generated
-	 * @ordered
-	 */
-    protected VarType var;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-    protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-    protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected ResourceBundleTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.RESOURCE_BUNDLE_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EList getDescription() {
-		if (description == null) {
-			description = new EObjectContainmentEList(DescriptionType.class, this, FacesConfigPackage.RESOURCE_BUNDLE_TYPE__DESCRIPTION);
-		}
-		return description;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EList getDisplayName() {
-		if (displayName == null) {
-			displayName = new EObjectContainmentEList(DisplayNameType.class, this, FacesConfigPackage.RESOURCE_BUNDLE_TYPE__DISPLAY_NAME);
-		}
-		return displayName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EList getIcon() {
-		if (icon == null) {
-			icon = new EObjectContainmentEList(IconType.class, this, FacesConfigPackage.RESOURCE_BUNDLE_TYPE__ICON);
-		}
-		return icon;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public BaseNameType getBaseName() {
-		if (baseName != null && baseName.eIsProxy()) {
-			InternalEObject oldBaseName = (InternalEObject)baseName;
-			baseName = (BaseNameType)eResolveProxy(oldBaseName);
-			if (baseName != oldBaseName) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, FacesConfigPackage.RESOURCE_BUNDLE_TYPE__BASE_NAME, oldBaseName, baseName));
-			}
-		}
-		return baseName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @return the base name 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public BaseNameType basicGetBaseName() {
-		return baseName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void setBaseName(BaseNameType newBaseName) {
-		BaseNameType oldBaseName = baseName;
-		baseName = newBaseName;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RESOURCE_BUNDLE_TYPE__BASE_NAME, oldBaseName, baseName));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public VarType getVar() {
-		if (var != null && var.eIsProxy()) {
-			InternalEObject oldVar = (InternalEObject)var;
-			var = (VarType)eResolveProxy(oldVar);
-			if (var != oldVar) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, FacesConfigPackage.RESOURCE_BUNDLE_TYPE__VAR, oldVar, var));
-			}
-		}
-		return var;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @return the variable 
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public VarType basicGetVar() {
-		return var;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void setVar(VarType newVar) {
-		VarType oldVar = var;
-		var = newVar;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RESOURCE_BUNDLE_TYPE__VAR, oldVar, var));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RESOURCE_BUNDLE_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__DESCRIPTION:
-				return ((InternalEList)getDescription()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__DISPLAY_NAME:
-				return ((InternalEList)getDisplayName()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__ICON:
-				return ((InternalEList)getIcon()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__DESCRIPTION:
-				return getDescription();
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__DISPLAY_NAME:
-				return getDisplayName();
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__ICON:
-				return getIcon();
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__BASE_NAME:
-				if (resolve) return getBaseName();
-				return basicGetBaseName();
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__VAR:
-				if (resolve) return getVar();
-				return basicGetVar();
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__DESCRIPTION:
-				getDescription().clear();
-				getDescription().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				getDisplayName().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__ICON:
-				getIcon().clear();
-				getIcon().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__BASE_NAME:
-				setBaseName((BaseNameType)newValue);
-				return;
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__VAR:
-				setVar((VarType)newValue);
-				return;
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__DESCRIPTION:
-				getDescription().clear();
-				return;
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				return;
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__ICON:
-				getIcon().clear();
-				return;
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__BASE_NAME:
-				setBaseName((BaseNameType)null);
-				return;
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__VAR:
-				setVar((VarType)null);
-				return;
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__DESCRIPTION:
-				return description != null && !description.isEmpty();
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__DISPLAY_NAME:
-				return displayName != null && !displayName.isEmpty();
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__ICON:
-				return icon != null && !icon.isEmpty();
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__BASE_NAME:
-				return baseName != null;
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__VAR:
-				return var != null;
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-    public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ResourceBundleTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ResourceHandlerTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ResourceHandlerTypeImpl.java
deleted file mode 100644
index 19ea0f2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ResourceHandlerTypeImpl.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ResourceHandlerType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Resource Handler Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ResourceHandlerTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ResourceHandlerTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ResourceHandlerTypeImpl extends EObjectImpl implements ResourceHandlerType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ResourceHandlerTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.RESOURCE_HANDLER_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RESOURCE_HANDLER_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.RESOURCE_HANDLER_TYPE__ID, oldId, id));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.RESOURCE_HANDLER_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.RESOURCE_HANDLER_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.RESOURCE_HANDLER_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.RESOURCE_HANDLER_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.RESOURCE_HANDLER_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.RESOURCE_HANDLER_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.RESOURCE_HANDLER_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.RESOURCE_HANDLER_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ResourceHandlerTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/SmallIconTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/SmallIconTypeImpl.java
deleted file mode 100644
index 8f3582f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/SmallIconTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.SmallIconType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Small Icon Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SmallIconTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SmallIconTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class SmallIconTypeImpl extends EObjectImpl implements SmallIconType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected SmallIconTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.SMALL_ICON_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.SMALL_ICON_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.SMALL_ICON_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.SMALL_ICON_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.SMALL_ICON_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.SMALL_ICON_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.SMALL_ICON_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.SMALL_ICON_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.SMALL_ICON_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.SMALL_ICON_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.SMALL_ICON_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //SmallIconTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/SourceClassTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/SourceClassTypeImpl.java
deleted file mode 100644
index d10ce02..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/SourceClassTypeImpl.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.SourceClassType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Source Class Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SourceClassTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SourceClassTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class SourceClassTypeImpl extends EObjectImpl implements SourceClassType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected SourceClassTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.SOURCE_CLASS_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.SOURCE_CLASS_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.SOURCE_CLASS_TYPE__ID, oldId, id));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.SOURCE_CLASS_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.SOURCE_CLASS_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.SOURCE_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.SOURCE_CLASS_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.SOURCE_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.SOURCE_CLASS_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.SOURCE_CLASS_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.SOURCE_CLASS_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //SourceClassTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/StateManagerTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/StateManagerTypeImpl.java
deleted file mode 100644
index fed3b97..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/StateManagerTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.StateManagerType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>State Manager Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.StateManagerTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.StateManagerTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class StateManagerTypeImpl extends EObjectImpl implements StateManagerType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected StateManagerTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.STATE_MANAGER_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.STATE_MANAGER_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.STATE_MANAGER_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.STATE_MANAGER_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.STATE_MANAGER_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.STATE_MANAGER_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.STATE_MANAGER_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.STATE_MANAGER_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.STATE_MANAGER_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.STATE_MANAGER_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.STATE_MANAGER_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //StateManagerTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/SuggestedValueTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/SuggestedValueTypeImpl.java
deleted file mode 100644
index 662fa42..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/SuggestedValueTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.SuggestedValueType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Suggested Value Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SuggestedValueTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SuggestedValueTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class SuggestedValueTypeImpl extends EObjectImpl implements SuggestedValueType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected SuggestedValueTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.SUGGESTED_VALUE_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.SUGGESTED_VALUE_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.SUGGESTED_VALUE_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.SUGGESTED_VALUE_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.SUGGESTED_VALUE_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.SUGGESTED_VALUE_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.SUGGESTED_VALUE_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.SUGGESTED_VALUE_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.SUGGESTED_VALUE_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.SUGGESTED_VALUE_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.SUGGESTED_VALUE_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //SuggestedValueTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/SupportedLocaleTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/SupportedLocaleTypeImpl.java
deleted file mode 100644
index 4ae4aed..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/SupportedLocaleTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.SupportedLocaleType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Supported Locale Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SupportedLocaleTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SupportedLocaleTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class SupportedLocaleTypeImpl extends EObjectImpl implements SupportedLocaleType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected SupportedLocaleTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.SUPPORTED_LOCALE_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.SUPPORTED_LOCALE_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.SUPPORTED_LOCALE_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.SUPPORTED_LOCALE_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.SUPPORTED_LOCALE_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.SUPPORTED_LOCALE_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.SUPPORTED_LOCALE_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.SUPPORTED_LOCALE_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.SUPPORTED_LOCALE_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.SUPPORTED_LOCALE_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.SUPPORTED_LOCALE_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //SupportedLocaleTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/SystemEventClassTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/SystemEventClassTypeImpl.java
deleted file mode 100644
index a32b0c1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/SystemEventClassTypeImpl.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.SystemEventClassType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>System Event Class Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SystemEventClassTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SystemEventClassTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class SystemEventClassTypeImpl extends EObjectImpl implements SystemEventClassType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected SystemEventClassTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.SYSTEM_EVENT_CLASS_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.SYSTEM_EVENT_CLASS_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.SYSTEM_EVENT_CLASS_TYPE__ID, oldId, id));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.SYSTEM_EVENT_CLASS_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.SYSTEM_EVENT_CLASS_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.SYSTEM_EVENT_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.SYSTEM_EVENT_CLASS_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.SYSTEM_EVENT_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.SYSTEM_EVENT_CLASS_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.SYSTEM_EVENT_CLASS_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.SYSTEM_EVENT_CLASS_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //SystemEventClassTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/SystemEventListenerClassTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/SystemEventListenerClassTypeImpl.java
deleted file mode 100644
index bfe4c2a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/SystemEventListenerClassTypeImpl.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerClassType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>System Event Listener Class Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SystemEventListenerClassTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SystemEventListenerClassTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class SystemEventListenerClassTypeImpl extends EObjectImpl implements SystemEventListenerClassType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected SystemEventListenerClassTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.SYSTEM_EVENT_LISTENER_CLASS_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.SYSTEM_EVENT_LISTENER_CLASS_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.SYSTEM_EVENT_LISTENER_CLASS_TYPE__ID, oldId, id));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_CLASS_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_CLASS_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_CLASS_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_CLASS_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_CLASS_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_CLASS_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //SystemEventListenerClassTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/SystemEventListenerTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/SystemEventListenerTypeImpl.java
deleted file mode 100644
index 26d8c6c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/SystemEventListenerTypeImpl.java
+++ /dev/null
@@ -1,393 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.SourceClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.SystemEventClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>System Event Listener Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SystemEventListenerTypeImpl#getSystemEventListenerClass <em>System Event Listener Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SystemEventListenerTypeImpl#getSystemEventClass <em>System Event Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SystemEventListenerTypeImpl#getSourceClass <em>Source Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.SystemEventListenerTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class SystemEventListenerTypeImpl extends EObjectImpl implements SystemEventListenerType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The cached value of the '{@link #getSystemEventListenerClass() <em>System Event Listener Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getSystemEventListenerClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected SystemEventListenerClassType systemEventListenerClass;
-
-	/**
-	 * The cached value of the '{@link #getSystemEventClass() <em>System Event Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getSystemEventClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected SystemEventClassType systemEventClass;
-
-	/**
-	 * The cached value of the '{@link #getSourceClass() <em>Source Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getSourceClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected SourceClassType sourceClass;
-
-	/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected SystemEventListenerTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.SYSTEM_EVENT_LISTENER_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SystemEventListenerClassType getSystemEventListenerClass() {
-		return systemEventListenerClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * @param newSystemEventListenerClass 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetSystemEventListenerClass(SystemEventListenerClassType newSystemEventListenerClass, NotificationChain msgs) {
-		SystemEventListenerClassType oldSystemEventListenerClass = systemEventListenerClass;
-		systemEventListenerClass = newSystemEventListenerClass;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_LISTENER_CLASS, oldSystemEventListenerClass, newSystemEventListenerClass);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setSystemEventListenerClass(SystemEventListenerClassType newSystemEventListenerClass) {
-		if (newSystemEventListenerClass != systemEventListenerClass) {
-			NotificationChain msgs = null;
-			if (systemEventListenerClass != null)
-				msgs = ((InternalEObject)systemEventListenerClass).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_LISTENER_CLASS, null, msgs);
-			if (newSystemEventListenerClass != null)
-				msgs = ((InternalEObject)newSystemEventListenerClass).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_LISTENER_CLASS, null, msgs);
-			msgs = basicSetSystemEventListenerClass(newSystemEventListenerClass, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_LISTENER_CLASS, newSystemEventListenerClass, newSystemEventListenerClass));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SystemEventClassType getSystemEventClass() {
-		return systemEventClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * @param newSystemEventClass 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetSystemEventClass(SystemEventClassType newSystemEventClass, NotificationChain msgs) {
-		SystemEventClassType oldSystemEventClass = systemEventClass;
-		systemEventClass = newSystemEventClass;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_CLASS, oldSystemEventClass, newSystemEventClass);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setSystemEventClass(SystemEventClassType newSystemEventClass) {
-		if (newSystemEventClass != systemEventClass) {
-			NotificationChain msgs = null;
-			if (systemEventClass != null)
-				msgs = ((InternalEObject)systemEventClass).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_CLASS, null, msgs);
-			if (newSystemEventClass != null)
-				msgs = ((InternalEObject)newSystemEventClass).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_CLASS, null, msgs);
-			msgs = basicSetSystemEventClass(newSystemEventClass, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_CLASS, newSystemEventClass, newSystemEventClass));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public SourceClassType getSourceClass() {
-		return sourceClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * @param newSourceClass 
-	 * @param msgs 
-	 * @return NotificationChain
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetSourceClass(SourceClassType newSourceClass, NotificationChain msgs) {
-		SourceClassType oldSourceClass = sourceClass;
-		sourceClass = newSourceClass;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SOURCE_CLASS, oldSourceClass, newSourceClass);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setSourceClass(SourceClassType newSourceClass) {
-		if (newSourceClass != sourceClass) {
-			NotificationChain msgs = null;
-			if (sourceClass != null)
-				msgs = ((InternalEObject)sourceClass).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SOURCE_CLASS, null, msgs);
-			if (newSourceClass != null)
-				msgs = ((InternalEObject)newSourceClass).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SOURCE_CLASS, null, msgs);
-			msgs = basicSetSourceClass(newSourceClass, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SOURCE_CLASS, newSourceClass, newSourceClass));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__ID, oldId, id));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_LISTENER_CLASS:
-				return basicSetSystemEventListenerClass(null, msgs);
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_CLASS:
-				return basicSetSystemEventClass(null, msgs);
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SOURCE_CLASS:
-				return basicSetSourceClass(null, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_LISTENER_CLASS:
-				return getSystemEventListenerClass();
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_CLASS:
-				return getSystemEventClass();
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SOURCE_CLASS:
-				return getSourceClass();
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_LISTENER_CLASS:
-				setSystemEventListenerClass((SystemEventListenerClassType)newValue);
-				return;
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_CLASS:
-				setSystemEventClass((SystemEventClassType)newValue);
-				return;
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SOURCE_CLASS:
-				setSourceClass((SourceClassType)newValue);
-				return;
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_LISTENER_CLASS:
-				setSystemEventListenerClass((SystemEventListenerClassType)null);
-				return;
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_CLASS:
-				setSystemEventClass((SystemEventClassType)null);
-				return;
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SOURCE_CLASS:
-				setSourceClass((SourceClassType)null);
-				return;
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_LISTENER_CLASS:
-				return systemEventListenerClass != null;
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SYSTEM_EVENT_CLASS:
-				return systemEventClass != null;
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__SOURCE_CLASS:
-				return sourceClass != null;
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //SystemEventListenerTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/TagHandlerDelegateFactoryTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/TagHandlerDelegateFactoryTypeImpl.java
deleted file mode 100644
index b5a9c4f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/TagHandlerDelegateFactoryTypeImpl.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.TagHandlerDelegateFactoryType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Tag Handler Delegate Factory Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.TagHandlerDelegateFactoryTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.TagHandlerDelegateFactoryTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class TagHandlerDelegateFactoryTypeImpl extends EObjectImpl implements TagHandlerDelegateFactoryType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected TagHandlerDelegateFactoryTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.TAG_HANDLER_DELEGATE_FACTORY_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.TAG_HANDLER_DELEGATE_FACTORY_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.TAG_HANDLER_DELEGATE_FACTORY_TYPE__ID, oldId, id));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.TAG_HANDLER_DELEGATE_FACTORY_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.TAG_HANDLER_DELEGATE_FACTORY_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.TAG_HANDLER_DELEGATE_FACTORY_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.TAG_HANDLER_DELEGATE_FACTORY_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.TAG_HANDLER_DELEGATE_FACTORY_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.TAG_HANDLER_DELEGATE_FACTORY_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.TAG_HANDLER_DELEGATE_FACTORY_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.TAG_HANDLER_DELEGATE_FACTORY_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //TagHandlerDelegateFactoryTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ToViewIdTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ToViewIdTypeImpl.java
deleted file mode 100644
index 891286a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ToViewIdTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ToViewIdType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>To View Id Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ToViewIdTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ToViewIdTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ToViewIdTypeImpl extends EObjectImpl implements ToViewIdType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ToViewIdTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.TO_VIEW_ID_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.TO_VIEW_ID_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.TO_VIEW_ID_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.TO_VIEW_ID_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.TO_VIEW_ID_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.TO_VIEW_ID_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.TO_VIEW_ID_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.TO_VIEW_ID_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.TO_VIEW_ID_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.TO_VIEW_ID_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.TO_VIEW_ID_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ToViewIdTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ValidatorClassTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ValidatorClassTypeImpl.java
deleted file mode 100644
index 7e7263f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ValidatorClassTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ValidatorClassType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Validator Class Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorClassTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorClassTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ValidatorClassTypeImpl extends EObjectImpl implements ValidatorClassType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ValidatorClassTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.VALIDATOR_CLASS_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VALIDATOR_CLASS_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VALIDATOR_CLASS_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.VALIDATOR_CLASS_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.VALIDATOR_CLASS_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.VALIDATOR_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.VALIDATOR_CLASS_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.VALIDATOR_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.VALIDATOR_CLASS_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.VALIDATOR_CLASS_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.VALIDATOR_CLASS_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ValidatorClassTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ValidatorExtensionTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ValidatorExtensionTypeImpl.java
deleted file mode 100644
index b3eede8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ValidatorExtensionTypeImpl.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ValidatorExtensionType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Validator Extension Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * </p>
- *
- * @generated
- */
-public class ValidatorExtensionTypeImpl extends ExtensionTypeImpl implements ValidatorExtensionType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    @SuppressWarnings("hiding")
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected ValidatorExtensionTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.VALIDATOR_EXTENSION_TYPE;
-	}
-
-} //ValidatorExtensionTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ValidatorIdTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ValidatorIdTypeImpl.java
deleted file mode 100644
index e5f4431..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ValidatorIdTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ValidatorIdType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Validator Id Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorIdTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorIdTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ValidatorIdTypeImpl extends EObjectImpl implements ValidatorIdType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ValidatorIdTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.VALIDATOR_ID_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VALIDATOR_ID_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VALIDATOR_ID_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.VALIDATOR_ID_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.VALIDATOR_ID_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.VALIDATOR_ID_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.VALIDATOR_ID_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.VALIDATOR_ID_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.VALIDATOR_ID_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.VALIDATOR_ID_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.VALIDATOR_ID_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ValidatorIdTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ValidatorTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ValidatorTypeImpl.java
deleted file mode 100644
index 7a266c7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ValidatorTypeImpl.java
+++ /dev/null
@@ -1,551 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
-
-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.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jst.jsf.facesconfig.emf.AttributeType;
-import org.eclipse.jst.jsf.facesconfig.emf.DescriptionType;
-import org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.IconType;
-import org.eclipse.jst.jsf.facesconfig.emf.PropertyType;
-import org.eclipse.jst.jsf.facesconfig.emf.ValidatorClassType;
-import org.eclipse.jst.jsf.facesconfig.emf.ValidatorExtensionType;
-import org.eclipse.jst.jsf.facesconfig.emf.ValidatorIdType;
-import org.eclipse.jst.jsf.facesconfig.emf.ValidatorType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Validator Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorTypeImpl#getDescription <em>Description</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorTypeImpl#getDisplayName <em>Display Name</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorTypeImpl#getIcon <em>Icon</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorTypeImpl#getValidatorId <em>Validator Id</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorTypeImpl#getValidatorClass <em>Validator Class</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorTypeImpl#getAttribute <em>Attribute</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorTypeImpl#getProperty <em>Property</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorTypeImpl#getValidatorExtension <em>Validator Extension</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValidatorTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ValidatorTypeImpl extends EObjectImpl implements ValidatorType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached value of the '{@link #getDescription() <em>Description</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDescription()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList description;
-
-    /**
-	 * The cached value of the '{@link #getDisplayName() <em>Display Name</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDisplayName()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList displayName;
-
-    /**
-	 * The cached value of the '{@link #getIcon() <em>Icon</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getIcon()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList icon;
-
-    /**
-	 * The cached value of the '{@link #getValidatorId() <em>Validator Id</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getValidatorId()
-	 * @generated
-	 * @ordered
-	 */
-	protected ValidatorIdType validatorId;
-
-    /**
-	 * The cached value of the '{@link #getValidatorClass() <em>Validator Class</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getValidatorClass()
-	 * @generated
-	 * @ordered
-	 */
-	protected ValidatorClassType validatorClass;
-
-    /**
-	 * The cached value of the '{@link #getAttribute() <em>Attribute</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getAttribute()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList attribute;
-
-    /**
-	 * The cached value of the '{@link #getProperty() <em>Property</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getProperty()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList property;
-
-    /**
-	 * The cached value of the '{@link #getValidatorExtension() <em>Validator Extension</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getValidatorExtension()
-	 * @generated
-	 * @ordered
-	 */
-    protected EList validatorExtension;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ValidatorTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.VALIDATOR_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDescription() {
-		if (description == null) {
-			description = new EObjectContainmentEList(DescriptionType.class, this, FacesConfigPackage.VALIDATOR_TYPE__DESCRIPTION);
-		}
-		return description;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getDisplayName() {
-		if (displayName == null) {
-			displayName = new EObjectContainmentEList(DisplayNameType.class, this, FacesConfigPackage.VALIDATOR_TYPE__DISPLAY_NAME);
-		}
-		return displayName;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getIcon() {
-		if (icon == null) {
-			icon = new EObjectContainmentEList(IconType.class, this, FacesConfigPackage.VALIDATOR_TYPE__ICON);
-		}
-		return icon;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValidatorIdType getValidatorId() {
-		return validatorId;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newValidatorId 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetValidatorId(ValidatorIdType newValidatorId, NotificationChain msgs) {
-		ValidatorIdType oldValidatorId = validatorId;
-		validatorId = newValidatorId;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_ID, oldValidatorId, newValidatorId);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setValidatorId(ValidatorIdType newValidatorId) {
-		if (newValidatorId != validatorId) {
-			NotificationChain msgs = null;
-			if (validatorId != null)
-				msgs = ((InternalEObject)validatorId).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_ID, null, msgs);
-			if (newValidatorId != null)
-				msgs = ((InternalEObject)newValidatorId).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_ID, null, msgs);
-			msgs = basicSetValidatorId(newValidatorId, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_ID, newValidatorId, newValidatorId));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ValidatorClassType getValidatorClass() {
-		return validatorClass;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * @param newValidatorClass 
-     * @param msgs 
-     * @return the notification chain 
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetValidatorClass(ValidatorClassType newValidatorClass, NotificationChain msgs) {
-		ValidatorClassType oldValidatorClass = validatorClass;
-		validatorClass = newValidatorClass;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_CLASS, oldValidatorClass, newValidatorClass);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setValidatorClass(ValidatorClassType newValidatorClass) {
-		if (newValidatorClass != validatorClass) {
-			NotificationChain msgs = null;
-			if (validatorClass != null)
-				msgs = ((InternalEObject)validatorClass).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_CLASS, null, msgs);
-			if (newValidatorClass != null)
-				msgs = ((InternalEObject)newValidatorClass).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_CLASS, null, msgs);
-			msgs = basicSetValidatorClass(newValidatorClass, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_CLASS, newValidatorClass, newValidatorClass));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getAttribute() {
-		if (attribute == null) {
-			attribute = new EObjectContainmentEList(AttributeType.class, this, FacesConfigPackage.VALIDATOR_TYPE__ATTRIBUTE);
-		}
-		return attribute;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList getProperty() {
-		if (property == null) {
-			property = new EObjectContainmentEList(PropertyType.class, this, FacesConfigPackage.VALIDATOR_TYPE__PROPERTY);
-		}
-		return property;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public EList getValidatorExtension() {
-		if (validatorExtension == null) {
-			validatorExtension = new EObjectContainmentEList(ValidatorExtensionType.class, this, FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_EXTENSION);
-		}
-		return validatorExtension;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VALIDATOR_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case FacesConfigPackage.VALIDATOR_TYPE__DESCRIPTION:
-				return ((InternalEList)getDescription()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.VALIDATOR_TYPE__DISPLAY_NAME:
-				return ((InternalEList)getDisplayName()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.VALIDATOR_TYPE__ICON:
-				return ((InternalEList)getIcon()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_ID:
-				return basicSetValidatorId(null, msgs);
-			case FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_CLASS:
-				return basicSetValidatorClass(null, msgs);
-			case FacesConfigPackage.VALIDATOR_TYPE__ATTRIBUTE:
-				return ((InternalEList)getAttribute()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.VALIDATOR_TYPE__PROPERTY:
-				return ((InternalEList)getProperty()).basicRemove(otherEnd, msgs);
-			case FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_EXTENSION:
-				return ((InternalEList)getValidatorExtension()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.VALIDATOR_TYPE__DESCRIPTION:
-				return getDescription();
-			case FacesConfigPackage.VALIDATOR_TYPE__DISPLAY_NAME:
-				return getDisplayName();
-			case FacesConfigPackage.VALIDATOR_TYPE__ICON:
-				return getIcon();
-			case FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_ID:
-				return getValidatorId();
-			case FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_CLASS:
-				return getValidatorClass();
-			case FacesConfigPackage.VALIDATOR_TYPE__ATTRIBUTE:
-				return getAttribute();
-			case FacesConfigPackage.VALIDATOR_TYPE__PROPERTY:
-				return getProperty();
-			case FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_EXTENSION:
-				return getValidatorExtension();
-			case FacesConfigPackage.VALIDATOR_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.VALIDATOR_TYPE__DESCRIPTION:
-				getDescription().clear();
-				getDescription().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.VALIDATOR_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				getDisplayName().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.VALIDATOR_TYPE__ICON:
-				getIcon().clear();
-				getIcon().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_ID:
-				setValidatorId((ValidatorIdType)newValue);
-				return;
-			case FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_CLASS:
-				setValidatorClass((ValidatorClassType)newValue);
-				return;
-			case FacesConfigPackage.VALIDATOR_TYPE__ATTRIBUTE:
-				getAttribute().clear();
-				getAttribute().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.VALIDATOR_TYPE__PROPERTY:
-				getProperty().clear();
-				getProperty().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_EXTENSION:
-				getValidatorExtension().clear();
-				getValidatorExtension().addAll((Collection)newValue);
-				return;
-			case FacesConfigPackage.VALIDATOR_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.VALIDATOR_TYPE__DESCRIPTION:
-				getDescription().clear();
-				return;
-			case FacesConfigPackage.VALIDATOR_TYPE__DISPLAY_NAME:
-				getDisplayName().clear();
-				return;
-			case FacesConfigPackage.VALIDATOR_TYPE__ICON:
-				getIcon().clear();
-				return;
-			case FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_ID:
-				setValidatorId((ValidatorIdType)null);
-				return;
-			case FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_CLASS:
-				setValidatorClass((ValidatorClassType)null);
-				return;
-			case FacesConfigPackage.VALIDATOR_TYPE__ATTRIBUTE:
-				getAttribute().clear();
-				return;
-			case FacesConfigPackage.VALIDATOR_TYPE__PROPERTY:
-				getProperty().clear();
-				return;
-			case FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_EXTENSION:
-				getValidatorExtension().clear();
-				return;
-			case FacesConfigPackage.VALIDATOR_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.VALIDATOR_TYPE__DESCRIPTION:
-				return description != null && !description.isEmpty();
-			case FacesConfigPackage.VALIDATOR_TYPE__DISPLAY_NAME:
-				return displayName != null && !displayName.isEmpty();
-			case FacesConfigPackage.VALIDATOR_TYPE__ICON:
-				return icon != null && !icon.isEmpty();
-			case FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_ID:
-				return validatorId != null;
-			case FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_CLASS:
-				return validatorClass != null;
-			case FacesConfigPackage.VALIDATOR_TYPE__ATTRIBUTE:
-				return attribute != null && !attribute.isEmpty();
-			case FacesConfigPackage.VALIDATOR_TYPE__PROPERTY:
-				return property != null && !property.isEmpty();
-			case FacesConfigPackage.VALIDATOR_TYPE__VALIDATOR_EXTENSION:
-				return validatorExtension != null && !validatorExtension.isEmpty();
-			case FacesConfigPackage.VALIDATOR_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ValidatorTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ValueClassTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ValueClassTypeImpl.java
deleted file mode 100644
index 451f90a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ValueClassTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ValueClassType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Value Class Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValueClassTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValueClassTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ValueClassTypeImpl extends EObjectImpl implements ValueClassType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ValueClassTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.VALUE_CLASS_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VALUE_CLASS_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VALUE_CLASS_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.VALUE_CLASS_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.VALUE_CLASS_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.VALUE_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.VALUE_CLASS_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.VALUE_CLASS_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.VALUE_CLASS_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.VALUE_CLASS_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.VALUE_CLASS_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ValueClassTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ValueTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ValueTypeImpl.java
deleted file mode 100644
index ebd907b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ValueTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ValueType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Value Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValueTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ValueTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ValueTypeImpl extends EObjectImpl implements ValueType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ValueTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.VALUE_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VALUE_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VALUE_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.VALUE_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.VALUE_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.VALUE_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.VALUE_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.VALUE_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.VALUE_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.VALUE_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.VALUE_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ValueTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/VarTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/VarTypeImpl.java
deleted file mode 100644
index fe14763..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/VarTypeImpl.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.VarType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Var Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.VarTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.VarTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class VarTypeImpl extends EObjectImpl implements VarType {
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-    protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-    protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-    protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-    protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected VarTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.VAR_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VAR_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VAR_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.VAR_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.VAR_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.VAR_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.VAR_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.VAR_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.VAR_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.VAR_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.VAR_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-    public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //VarTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/VariableResolverTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/VariableResolverTypeImpl.java
deleted file mode 100644
index 80ce3c2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/VariableResolverTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.VariableResolverType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Variable Resolver Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.VariableResolverTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.VariableResolverTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class VariableResolverTypeImpl extends EObjectImpl implements VariableResolverType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected VariableResolverTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.VARIABLE_RESOLVER_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VARIABLE_RESOLVER_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VARIABLE_RESOLVER_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.VARIABLE_RESOLVER_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.VARIABLE_RESOLVER_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.VARIABLE_RESOLVER_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.VARIABLE_RESOLVER_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.VARIABLE_RESOLVER_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.VARIABLE_RESOLVER_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.VARIABLE_RESOLVER_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.VARIABLE_RESOLVER_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //VariableResolverTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ViewDeclarationLanguageFactoryTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ViewDeclarationLanguageFactoryTypeImpl.java
deleted file mode 100644
index 561c7fc..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ViewDeclarationLanguageFactoryTypeImpl.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ViewDeclarationLanguageFactoryType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>View Declaration Language Factory Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ViewDeclarationLanguageFactoryTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ViewDeclarationLanguageFactoryTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ViewDeclarationLanguageFactoryTypeImpl extends EObjectImpl implements ViewDeclarationLanguageFactoryType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ViewDeclarationLanguageFactoryTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE__ID, oldId, id));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ViewDeclarationLanguageFactoryTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ViewHandlerTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ViewHandlerTypeImpl.java
deleted file mode 100644
index e6f1163..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/ViewHandlerTypeImpl.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.ViewHandlerType;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>View Handler Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ViewHandlerTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.ViewHandlerTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ViewHandlerTypeImpl extends EObjectImpl implements ViewHandlerType {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-    /**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-    /**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ViewHandlerTypeImpl() {
-		super();
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.VIEW_HANDLER_TYPE;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VIEW_HANDLER_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VIEW_HANDLER_TYPE__ID, oldId, id));
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.VIEW_HANDLER_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.VIEW_HANDLER_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.VIEW_HANDLER_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.VIEW_HANDLER_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.VIEW_HANDLER_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.VIEW_HANDLER_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-	 * @generated
-	 */
-    public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.VIEW_HANDLER_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.VIEW_HANDLER_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //ViewHandlerTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/VisitContextFactoryTypeImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/VisitContextFactoryTypeImpl.java
deleted file mode 100644
index db7a358..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/VisitContextFactoryTypeImpl.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.EObjectImpl;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.jst.jsf.facesconfig.emf.VisitContextFactoryType;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Visit Context Factory Type</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.VisitContextFactoryTypeImpl#getTextContent <em>Text Content</em>}</li>
- *   <li>{@link org.eclipse.jst.jsf.facesconfig.emf.impl.VisitContextFactoryTypeImpl#getId <em>Id</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class VisitContextFactoryTypeImpl extends EObjectImpl implements VisitContextFactoryType {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-	/**
-	 * The default value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String TEXT_CONTENT_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getTextContent() <em>Text Content</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getTextContent()
-	 * @generated
-	 * @ordered
-	 */
-	protected String textContent = TEXT_CONTENT_EDEFAULT;
-
-	/**
-	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String ID_EDEFAULT = null;
-
-	/**
-	 * The cached value of the '{@link #getId() <em>Id</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getId()
-	 * @generated
-	 * @ordered
-	 */
-	protected String id = ID_EDEFAULT;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected VisitContextFactoryTypeImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected EClass eStaticClass() {
-		return FacesConfigPackage.Literals.VISIT_CONTEXT_FACTORY_TYPE;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getTextContent() {
-		return textContent;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setTextContent(String newTextContent) {
-		String oldTextContent = textContent;
-		textContent = newTextContent;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VISIT_CONTEXT_FACTORY_TYPE__TEXT_CONTENT, oldTextContent, textContent));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getId() {
-		return id;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setId(String newId) {
-		String oldId = id;
-		id = newId;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, FacesConfigPackage.VISIT_CONTEXT_FACTORY_TYPE__ID, oldId, id));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case FacesConfigPackage.VISIT_CONTEXT_FACTORY_TYPE__TEXT_CONTENT:
-				return getTextContent();
-			case FacesConfigPackage.VISIT_CONTEXT_FACTORY_TYPE__ID:
-				return getId();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case FacesConfigPackage.VISIT_CONTEXT_FACTORY_TYPE__TEXT_CONTENT:
-				setTextContent((String)newValue);
-				return;
-			case FacesConfigPackage.VISIT_CONTEXT_FACTORY_TYPE__ID:
-				setId((String)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.VISIT_CONTEXT_FACTORY_TYPE__TEXT_CONTENT:
-				setTextContent(TEXT_CONTENT_EDEFAULT);
-				return;
-			case FacesConfigPackage.VISIT_CONTEXT_FACTORY_TYPE__ID:
-				setId(ID_EDEFAULT);
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case FacesConfigPackage.VISIT_CONTEXT_FACTORY_TYPE__TEXT_CONTENT:
-				return TEXT_CONTENT_EDEFAULT == null ? textContent != null : !TEXT_CONTENT_EDEFAULT.equals(textContent);
-			case FacesConfigPackage.VISIT_CONTEXT_FACTORY_TYPE__ID:
-				return ID_EDEFAULT == null ? id != null : !ID_EDEFAULT.equals(id);
-		}
-		return super.eIsSet(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public String toString() {
-		if (eIsProxy()) return super.toString();
-
-		StringBuffer result = new StringBuffer(super.toString());
-		result.append(" (textContent: "); //$NON-NLS-1$
-		result.append(textContent);
-		result.append(", id: "); //$NON-NLS-1$
-		result.append(id);
-		result.append(')');
-		return result.toString();
-	}
-
-} //VisitContextFactoryTypeImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/package-info.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/package-info.java
deleted file mode 100644
index 13588b7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/impl/package-info.java
+++ /dev/null
@@ -1,19 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Oracle - initial API and implementation
- *    
- ********************************************************************************/
-
-/**
- * EMF model implementations for JSF application configuration files (deprecated). 
- * <p>
- * Deprecated - should use interfaces in the org.eclipse.jst.jsf.facesconfig.emf package   
- * This package will be removed from the MANIFEST.MF as public API in a future release.
- */
-package org.eclipse.jst.jsf.facesconfig.emf.impl;
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/package-info.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/package-info.java
deleted file mode 100644
index b56d56a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/package-info.java
+++ /dev/null
@@ -1,16 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Oracle - initial API and implementation
- *    
- ********************************************************************************/
-
-/**
- * EMF model for JSF application configuration files. 
- */
-package org.eclipse.jst.jsf.facesconfig.emf;
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/util/FacesConfigAdapterFactory.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/util/FacesConfigAdapterFactory.java
deleted file mode 100644
index 93d83a0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/util/FacesConfigAdapterFactory.java
+++ /dev/null
@@ -1,2204 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.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.jst.jsf.facesconfig.emf.*;
-
-
-/**
- * <!-- 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.jst.jsf.facesconfig.emf.FacesConfigPackage
- * @generated
- */
-public class FacesConfigAdapterFactory extends AdapterFactoryImpl {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached model package.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected static FacesConfigPackage modelPackage;
-
-    /**
-	 * Creates an instance of the adapter factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FacesConfigAdapterFactory() {
-		if (modelPackage == null) {
-			modelPackage = FacesConfigPackage.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
-	 */
-	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 FacesConfigSwitch modelSwitch =
-        new FacesConfigSwitch() {
-			public Object caseAbsoluteOrderingType(AbsoluteOrderingType object) {
-				return createAbsoluteOrderingTypeAdapter();
-			}
-			public Object caseActionListenerType(ActionListenerType object) {
-				return createActionListenerTypeAdapter();
-			}
-			public Object caseApplicationFactoryType(ApplicationFactoryType object) {
-				return createApplicationFactoryTypeAdapter();
-			}
-			public Object caseApplicationType(ApplicationType object) {
-				return createApplicationTypeAdapter();
-			}
-			public Object caseApplicationExtensionType(ApplicationExtensionType object) {
-				return createApplicationExtensionTypeAdapter();
-			}
-			public Object caseAttributeClassType(AttributeClassType object) {
-				return createAttributeClassTypeAdapter();
-			}
-			public Object caseAttributeExtensionType(AttributeExtensionType object) {
-				return createAttributeExtensionTypeAdapter();
-			}
-			public Object caseAttributeNameType(AttributeNameType object) {
-				return createAttributeNameTypeAdapter();
-			}
-			public Object caseAttributeType(AttributeType object) {
-				return createAttributeTypeAdapter();
-			}
-			public Object caseBehaviorClassType(BehaviorClassType object) {
-				return createBehaviorClassTypeAdapter();
-			}
-			public Object caseBehaviorIdType(BehaviorIdType object) {
-				return createBehaviorIdTypeAdapter();
-			}
-			public Object caseBehaviorType(BehaviorType object) {
-				return createBehaviorTypeAdapter();
-			}
-			public Object caseBehaviorExtensionType(BehaviorExtensionType object) {
-				return createBehaviorExtensionTypeAdapter();
-			}
-			public Object caseClientBehaviorRendererClassType(ClientBehaviorRendererClassType object) {
-				return createClientBehaviorRendererClassTypeAdapter();
-			}
-			public Object caseClientBehaviorRendererType(ClientBehaviorRendererType object) {
-				return createClientBehaviorRendererTypeAdapter();
-			}
-			public Object caseClientBehaviorRendererTypeType(ClientBehaviorRendererTypeType object) {
-				return createClientBehaviorRendererTypeTypeAdapter();
-			}
-			public Object caseComponentClassType(ComponentClassType object) {
-				return createComponentClassTypeAdapter();
-			}
-			public Object caseComponentExtensionType(ComponentExtensionType object) {
-				return createComponentExtensionTypeAdapter();
-			}
-			public Object caseComponentFamilyType(ComponentFamilyType object) {
-				return createComponentFamilyTypeAdapter();
-			}
-			public Object caseComponentType(ComponentType object) {
-				return createComponentTypeAdapter();
-			}
-			public Object caseComponentTypeType(ComponentTypeType object) {
-				return createComponentTypeTypeAdapter();
-			}
-			public Object caseConverterClassType(ConverterClassType object) {
-				return createConverterClassTypeAdapter();
-			}
-			public Object caseConverterForClassType(ConverterForClassType object) {
-				return createConverterForClassTypeAdapter();
-			}
-			public Object caseConverterIdType(ConverterIdType object) {
-				return createConverterIdTypeAdapter();
-			}
-			public Object caseConverterType(ConverterType object) {
-				return createConverterTypeAdapter();
-			}
-			public Object caseConverterExtensionType(ConverterExtensionType object) {
-				return createConverterExtensionTypeAdapter();
-			}
-			public Object caseDefaultLocaleType(DefaultLocaleType object) {
-				return createDefaultLocaleTypeAdapter();
-			}
-			public Object caseDefaultRenderKitIdType(DefaultRenderKitIdType object) {
-				return createDefaultRenderKitIdTypeAdapter();
-			}
-			public Object caseDefaultValidatorsType(DefaultValidatorsType object) {
-				return createDefaultValidatorsTypeAdapter();
-			}
-			public Object caseDefaultValueType(DefaultValueType object) {
-				return createDefaultValueTypeAdapter();
-			}
-			public Object caseDescriptionType(DescriptionType object) {
-				return createDescriptionTypeAdapter();
-			}
-			public Object caseDisplayNameType(DisplayNameType object) {
-				return createDisplayNameTypeAdapter();
-			}
-			public Object caseDocumentRoot(DocumentRoot object) {
-				return createDocumentRootAdapter();
-			}
-			public Object caseDynamicAttribute(DynamicAttribute object) {
-				return createDynamicAttributeAdapter();
-			}
-			public Object caseDynamicElement(DynamicElement object) {
-				return createDynamicElementAdapter();
-			}
-			public Object caseELResolverType(ELResolverType object) {
-				return createELResolverTypeAdapter();
-			}
-			public Object caseExceptionHandlerFactoryType(ExceptionHandlerFactoryType object) {
-				return createExceptionHandlerFactoryTypeAdapter();
-			}
-			public Object caseExtensionType(ExtensionType object) {
-				return createExtensionTypeAdapter();
-			}
-			public Object caseExternalContextFactoryType(ExternalContextFactoryType object) {
-				return createExternalContextFactoryTypeAdapter();
-			}
-			public Object caseFacesConfigType(FacesConfigType object) {
-				return createFacesConfigTypeAdapter();
-			}
-			public Object caseFacesConfigExtensionType(FacesConfigExtensionType object) {
-				return createFacesConfigExtensionTypeAdapter();
-			}
-			public Object caseFacesContextFactoryType(FacesContextFactoryType object) {
-				return createFacesContextFactoryTypeAdapter();
-			}
-			public Object caseFacetExtensionType(FacetExtensionType object) {
-				return createFacetExtensionTypeAdapter();
-			}
-			public Object caseFacetNameType(FacetNameType object) {
-				return createFacetNameTypeAdapter();
-			}
-			public Object caseFacetType(FacetType object) {
-				return createFacetTypeAdapter();
-			}
-			public Object caseFactoryType(FactoryType object) {
-				return createFactoryTypeAdapter();
-			}
-			public Object caseFactoryExtensionType(FactoryExtensionType object) {
-				return createFactoryExtensionTypeAdapter();
-			}
-			public Object caseFromActionType(FromActionType object) {
-				return createFromActionTypeAdapter();
-			}
-			public Object caseFromOutcomeType(FromOutcomeType object) {
-				return createFromOutcomeTypeAdapter();
-			}
-			public Object caseFromViewIdType(FromViewIdType object) {
-				return createFromViewIdTypeAdapter();
-			}
-			public Object caseIconType(IconType object) {
-				return createIconTypeAdapter();
-			}
-			public Object caseIfType(IfType object) {
-				return createIfTypeAdapter();
-			}
-			public Object caseKeyClassType(KeyClassType object) {
-				return createKeyClassTypeAdapter();
-			}
-			public Object caseKeyType(KeyType object) {
-				return createKeyTypeAdapter();
-			}
-			public Object caseLargeIconType(LargeIconType object) {
-				return createLargeIconTypeAdapter();
-			}
-			public Object caseLifecycleFactoryType(LifecycleFactoryType object) {
-				return createLifecycleFactoryTypeAdapter();
-			}
-			public Object caseLifecycleType(LifecycleType object) {
-				return createLifecycleTypeAdapter();
-			}
-			public Object caseLifecycleExtensionType(LifecycleExtensionType object) {
-				return createLifecycleExtensionTypeAdapter();
-			}
-			public Object caseListEntriesType(ListEntriesType object) {
-				return createListEntriesTypeAdapter();
-			}
-			public Object caseLocaleConfigType(LocaleConfigType object) {
-				return createLocaleConfigTypeAdapter();
-			}
-			public Object caseManagedBeanClassType(ManagedBeanClassType object) {
-				return createManagedBeanClassTypeAdapter();
-			}
-			public Object caseManagedBeanNameType(ManagedBeanNameType object) {
-				return createManagedBeanNameTypeAdapter();
-			}
-			public Object caseManagedBeanScopeType(ManagedBeanScopeType object) {
-				return createManagedBeanScopeTypeAdapter();
-			}
-			public Object caseManagedBeanType(ManagedBeanType object) {
-				return createManagedBeanTypeAdapter();
-			}
-			public Object caseManagedBeanExtensionType(ManagedBeanExtensionType object) {
-				return createManagedBeanExtensionTypeAdapter();
-			}
-			public Object caseManagedPropertyType(ManagedPropertyType object) {
-				return createManagedPropertyTypeAdapter();
-			}
-			public Object caseMapEntriesType(MapEntriesType object) {
-				return createMapEntriesTypeAdapter();
-			}
-			public Object caseMapEntryType(MapEntryType object) {
-				return createMapEntryTypeAdapter();
-			}
-			public Object caseMessageBundleType(MessageBundleType object) {
-				return createMessageBundleTypeAdapter();
-			}
-			public Object caseNameType(NameType object) {
-				return createNameTypeAdapter();
-			}
-			public Object caseNavigationCaseType(NavigationCaseType object) {
-				return createNavigationCaseTypeAdapter();
-			}
-			public Object caseNavigationHandlerType(NavigationHandlerType object) {
-				return createNavigationHandlerTypeAdapter();
-			}
-			public Object caseNavigationRuleType(NavigationRuleType object) {
-				return createNavigationRuleTypeAdapter();
-			}
-			public Object caseNavigationRuleExtensionType(NavigationRuleExtensionType object) {
-				return createNavigationRuleExtensionTypeAdapter();
-			}
-			public Object caseNullValueType(NullValueType object) {
-				return createNullValueTypeAdapter();
-			}
-			public Object caseOrderingType(OrderingType object) {
-				return createOrderingTypeAdapter();
-			}
-			public Object caseOrderingOrderingType(OrderingOrderingType object) {
-				return createOrderingOrderingTypeAdapter();
-			}
-			public Object caseOrderingOthersType(OrderingOthersType object) {
-				return createOrderingOthersTypeAdapter();
-			}
-			public Object casePartialViewContextFactoryType(PartialViewContextFactoryType object) {
-				return createPartialViewContextFactoryTypeAdapter();
-			}
-			public Object casePhaseListenerType(PhaseListenerType object) {
-				return createPhaseListenerTypeAdapter();
-			}
-			public Object casePropertyClassType(PropertyClassType object) {
-				return createPropertyClassTypeAdapter();
-			}
-			public Object casePropertyExtensionType(PropertyExtensionType object) {
-				return createPropertyExtensionTypeAdapter();
-			}
-			public Object casePropertyNameType(PropertyNameType object) {
-				return createPropertyNameTypeAdapter();
-			}
-			public Object casePropertyResolverType(PropertyResolverType object) {
-				return createPropertyResolverTypeAdapter();
-			}
-			public Object casePropertyType(PropertyType object) {
-				return createPropertyTypeAdapter();
-			}
-			public Object caseRedirectType(RedirectType object) {
-				return createRedirectTypeAdapter();
-			}
-			public Object caseRedirectViewParamType(RedirectViewParamType object) {
-				return createRedirectViewParamTypeAdapter();
-			}
-			public Object caseReferencedBeanClassType(ReferencedBeanClassType object) {
-				return createReferencedBeanClassTypeAdapter();
-			}
-			public Object caseReferencedBeanNameType(ReferencedBeanNameType object) {
-				return createReferencedBeanNameTypeAdapter();
-			}
-			public Object caseReferencedBeanType(ReferencedBeanType object) {
-				return createReferencedBeanTypeAdapter();
-			}
-			public Object caseRendererClassType(RendererClassType object) {
-				return createRendererClassTypeAdapter();
-			}
-			public Object caseRendererExtensionType(RendererExtensionType object) {
-				return createRendererExtensionTypeAdapter();
-			}
-			public Object caseRendererType(RendererType object) {
-				return createRendererTypeAdapter();
-			}
-			public Object caseRendererTypeType(RendererTypeType object) {
-				return createRendererTypeTypeAdapter();
-			}
-			public Object caseRenderKitClassType(RenderKitClassType object) {
-				return createRenderKitClassTypeAdapter();
-			}
-			public Object caseRenderKitFactoryType(RenderKitFactoryType object) {
-				return createRenderKitFactoryTypeAdapter();
-			}
-			public Object caseRenderKitIdType(RenderKitIdType object) {
-				return createRenderKitIdTypeAdapter();
-			}
-			public Object caseRenderKitType(RenderKitType object) {
-				return createRenderKitTypeAdapter();
-			}
-			public Object caseRenderKitExtensionType(RenderKitExtensionType object) {
-				return createRenderKitExtensionTypeAdapter();
-			}
-			public Object caseResourceHandlerType(ResourceHandlerType object) {
-				return createResourceHandlerTypeAdapter();
-			}
-			public Object caseSmallIconType(SmallIconType object) {
-				return createSmallIconTypeAdapter();
-			}
-			public Object caseSourceClassType(SourceClassType object) {
-				return createSourceClassTypeAdapter();
-			}
-			public Object caseStateManagerType(StateManagerType object) {
-				return createStateManagerTypeAdapter();
-			}
-			public Object caseSuggestedValueType(SuggestedValueType object) {
-				return createSuggestedValueTypeAdapter();
-			}
-			public Object caseSupportedLocaleType(SupportedLocaleType object) {
-				return createSupportedLocaleTypeAdapter();
-			}
-			public Object caseSystemEventClassType(SystemEventClassType object) {
-				return createSystemEventClassTypeAdapter();
-			}
-			public Object caseSystemEventListenerClassType(SystemEventListenerClassType object) {
-				return createSystemEventListenerClassTypeAdapter();
-			}
-			public Object caseSystemEventListenerType(SystemEventListenerType object) {
-				return createSystemEventListenerTypeAdapter();
-			}
-			public Object caseTagHandlerDelegateFactoryType(TagHandlerDelegateFactoryType object) {
-				return createTagHandlerDelegateFactoryTypeAdapter();
-			}
-			public Object caseToViewIdType(ToViewIdType object) {
-				return createToViewIdTypeAdapter();
-			}
-			public Object caseValidatorClassType(ValidatorClassType object) {
-				return createValidatorClassTypeAdapter();
-			}
-			public Object caseValidatorIdType(ValidatorIdType object) {
-				return createValidatorIdTypeAdapter();
-			}
-			public Object caseValidatorType(ValidatorType object) {
-				return createValidatorTypeAdapter();
-			}
-			public Object caseValidatorExtensionType(ValidatorExtensionType object) {
-				return createValidatorExtensionTypeAdapter();
-			}
-			public Object caseValueClassType(ValueClassType object) {
-				return createValueClassTypeAdapter();
-			}
-			public Object caseValueType(ValueType object) {
-				return createValueTypeAdapter();
-			}
-			public Object caseVariableResolverType(VariableResolverType object) {
-				return createVariableResolverTypeAdapter();
-			}
-			public Object caseViewHandlerType(ViewHandlerType object) {
-				return createViewHandlerTypeAdapter();
-			}
-			public Object caseResourceBundleType(ResourceBundleType object) {
-				return createResourceBundleTypeAdapter();
-			}
-			public Object caseBaseNameType(BaseNameType object) {
-				return createBaseNameTypeAdapter();
-			}
-			public Object caseVarType(VarType object) {
-				return createVarTypeAdapter();
-			}
-			public Object caseViewDeclarationLanguageFactoryType(ViewDeclarationLanguageFactoryType object) {
-				return createViewDeclarationLanguageFactoryTypeAdapter();
-			}
-			public Object caseVisitContextFactoryType(VisitContextFactoryType object) {
-				return createVisitContextFactoryTypeAdapter();
-			}
-			public Object 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
-	 */
-	public Adapter createAdapter(Notifier target) {
-		return (Adapter)modelSwitch.doSwitch((EObject)target);
-	}
-
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.AbsoluteOrderingType <em>Absolute Ordering Type</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.jst.jsf.facesconfig.emf.AbsoluteOrderingType
-	 * @generated
-	 */
-	public Adapter createAbsoluteOrderingTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ActionListenerType <em>Action Listener Type</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.jst.jsf.facesconfig.emf.ActionListenerType
-	 * @generated
-	 */
-	public Adapter createActionListenerTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationFactoryType <em>Application Factory Type</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.jst.jsf.facesconfig.emf.ApplicationFactoryType
-	 * @generated
-	 */
-	public Adapter createApplicationFactoryTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationType <em>Application Type</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.jst.jsf.facesconfig.emf.ApplicationType
-	 * @generated
-	 */
-	public Adapter createApplicationTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeClassType <em>Attribute Class Type</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.jst.jsf.facesconfig.emf.AttributeClassType
-	 * @generated
-	 */
-	public Adapter createAttributeClassTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeExtensionType <em>Attribute Extension Type</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.jst.jsf.facesconfig.emf.AttributeExtensionType
-	 * @generated
-	 */
-	public Adapter createAttributeExtensionTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeNameType <em>Attribute Name Type</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.jst.jsf.facesconfig.emf.AttributeNameType
-	 * @generated
-	 */
-	public Adapter createAttributeNameTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.AttributeType <em>Attribute Type</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.jst.jsf.facesconfig.emf.AttributeType
-	 * @generated
-	 */
-	public Adapter createAttributeTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorClassType <em>Behavior Class Type</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.jst.jsf.facesconfig.emf.BehaviorClassType
-	 * @generated
-	 */
-	public Adapter createBehaviorClassTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorIdType <em>Behavior Id Type</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.jst.jsf.facesconfig.emf.BehaviorIdType
-	 * @generated
-	 */
-	public Adapter createBehaviorIdTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorType <em>Behavior Type</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.jst.jsf.facesconfig.emf.BehaviorType
-	 * @generated
-	 */
-	public Adapter createBehaviorTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.BehaviorExtensionType <em>Behavior Extension Type</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.jst.jsf.facesconfig.emf.BehaviorExtensionType
-	 * @generated
-	 */
-	public Adapter createBehaviorExtensionTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererClassType <em>Client Behavior Renderer Class Type</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.jst.jsf.facesconfig.emf.ClientBehaviorRendererClassType
-	 * @generated
-	 */
-	public Adapter createClientBehaviorRendererClassTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererType <em>Client Behavior Renderer Type</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.jst.jsf.facesconfig.emf.ClientBehaviorRendererType
-	 * @generated
-	 */
-	public Adapter createClientBehaviorRendererTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ClientBehaviorRendererTypeType <em>Client Behavior Renderer Type Type</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.jst.jsf.facesconfig.emf.ClientBehaviorRendererTypeType
-	 * @generated
-	 */
-	public Adapter createClientBehaviorRendererTypeTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentClassType <em>Component Class Type</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.jst.jsf.facesconfig.emf.ComponentClassType
-	 * @generated
-	 */
-	public Adapter createComponentClassTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentExtensionType <em>Component Extension Type</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.jst.jsf.facesconfig.emf.ComponentExtensionType
-	 * @generated
-	 */
-	public Adapter createComponentExtensionTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentFamilyType <em>Component Family Type</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.jst.jsf.facesconfig.emf.ComponentFamilyType
-	 * @generated
-	 */
-	public Adapter createComponentFamilyTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentType <em>Component Type</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.jst.jsf.facesconfig.emf.ComponentType
-	 * @generated
-	 */
-	public Adapter createComponentTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ComponentTypeType <em>Component Type Type</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.jst.jsf.facesconfig.emf.ComponentTypeType
-	 * @generated
-	 */
-	public Adapter createComponentTypeTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterClassType <em>Converter Class Type</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.jst.jsf.facesconfig.emf.ConverterClassType
-	 * @generated
-	 */
-	public Adapter createConverterClassTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterForClassType <em>Converter For Class Type</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.jst.jsf.facesconfig.emf.ConverterForClassType
-	 * @generated
-	 */
-	public Adapter createConverterForClassTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterIdType <em>Converter Id Type</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.jst.jsf.facesconfig.emf.ConverterIdType
-	 * @generated
-	 */
-	public Adapter createConverterIdTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterType <em>Converter Type</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.jst.jsf.facesconfig.emf.ConverterType
-	 * @generated
-	 */
-	public Adapter createConverterTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultLocaleType <em>Default Locale Type</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.jst.jsf.facesconfig.emf.DefaultLocaleType
-	 * @generated
-	 */
-	public Adapter createDefaultLocaleTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultRenderKitIdType <em>Default Render Kit Id Type</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.jst.jsf.facesconfig.emf.DefaultRenderKitIdType
-	 * @generated
-	 */
-	public Adapter createDefaultRenderKitIdTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValidatorsType <em>Default Validators Type</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.jst.jsf.facesconfig.emf.DefaultValidatorsType
-	 * @generated
-	 */
-	public Adapter createDefaultValidatorsTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.DefaultValueType <em>Default Value Type</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.jst.jsf.facesconfig.emf.DefaultValueType
-	 * @generated
-	 */
-	public Adapter createDefaultValueTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.DescriptionType <em>Description Type</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.jst.jsf.facesconfig.emf.DescriptionType
-	 * @generated
-	 */
-	public Adapter createDescriptionTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.DisplayNameType <em>Display Name Type</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.jst.jsf.facesconfig.emf.DisplayNameType
-	 * @generated
-	 */
-	public Adapter createDisplayNameTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.DocumentRoot <em>Document Root</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.jst.jsf.facesconfig.emf.DocumentRoot
-	 * @generated
-	 */
-	public Adapter createDocumentRootAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.DynamicAttribute <em>Dynamic Attribute</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.jst.jsf.facesconfig.emf.DynamicAttribute
-	 * @generated
-	 */
-    public Adapter createDynamicAttributeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.DynamicElement <em>Dynamic 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.jst.jsf.facesconfig.emf.DynamicElement
-	 * @generated
-	 */
-    public Adapter createDynamicElementAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ELResolverType <em>EL Resolver Type</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.jst.jsf.facesconfig.emf.ELResolverType
-	 * @generated
-	 */
-    public Adapter createELResolverTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ExceptionHandlerFactoryType <em>Exception Handler Factory Type</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.jst.jsf.facesconfig.emf.ExceptionHandlerFactoryType
-	 * @generated
-	 */
-	public Adapter createExceptionHandlerFactoryTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType <em>Type</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.jst.jsf.facesconfig.emf.FacesConfigType
-	 * @generated
-	 */
-	public Adapter createFacesConfigTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesContextFactoryType <em>Faces Context Factory Type</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.jst.jsf.facesconfig.emf.FacesContextFactoryType
-	 * @generated
-	 */
-	public Adapter createFacesContextFactoryTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.FacetExtensionType <em>Facet Extension Type</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.jst.jsf.facesconfig.emf.FacetExtensionType
-	 * @generated
-	 */
-	public Adapter createFacetExtensionTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.FacetNameType <em>Facet Name Type</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.jst.jsf.facesconfig.emf.FacetNameType
-	 * @generated
-	 */
-	public Adapter createFacetNameTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.FacetType <em>Facet Type</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.jst.jsf.facesconfig.emf.FacetType
-	 * @generated
-	 */
-	public Adapter createFacetTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryType <em>Factory Type</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.jst.jsf.facesconfig.emf.FactoryType
-	 * @generated
-	 */
-	public Adapter createFactoryTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.FromActionType <em>From Action Type</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.jst.jsf.facesconfig.emf.FromActionType
-	 * @generated
-	 */
-	public Adapter createFromActionTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.FromOutcomeType <em>From Outcome Type</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.jst.jsf.facesconfig.emf.FromOutcomeType
-	 * @generated
-	 */
-	public Adapter createFromOutcomeTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.FromViewIdType <em>From View Id Type</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.jst.jsf.facesconfig.emf.FromViewIdType
-	 * @generated
-	 */
-	public Adapter createFromViewIdTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.IconType <em>Icon Type</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.jst.jsf.facesconfig.emf.IconType
-	 * @generated
-	 */
-	public Adapter createIconTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.IfType <em>If Type</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.jst.jsf.facesconfig.emf.IfType
-	 * @generated
-	 */
-	public Adapter createIfTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.KeyClassType <em>Key Class Type</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.jst.jsf.facesconfig.emf.KeyClassType
-	 * @generated
-	 */
-	public Adapter createKeyClassTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.KeyType <em>Key Type</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.jst.jsf.facesconfig.emf.KeyType
-	 * @generated
-	 */
-	public Adapter createKeyTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.LargeIconType <em>Large Icon Type</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.jst.jsf.facesconfig.emf.LargeIconType
-	 * @generated
-	 */
-	public Adapter createLargeIconTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleFactoryType <em>Lifecycle Factory Type</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.jst.jsf.facesconfig.emf.LifecycleFactoryType
-	 * @generated
-	 */
-	public Adapter createLifecycleFactoryTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleType <em>Lifecycle Type</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.jst.jsf.facesconfig.emf.LifecycleType
-	 * @generated
-	 */
-	public Adapter createLifecycleTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ListEntriesType <em>List Entries Type</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.jst.jsf.facesconfig.emf.ListEntriesType
-	 * @generated
-	 */
-	public Adapter createListEntriesTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.LocaleConfigType <em>Locale Config Type</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.jst.jsf.facesconfig.emf.LocaleConfigType
-	 * @generated
-	 */
-	public Adapter createLocaleConfigTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanClassType <em>Managed Bean Class Type</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.jst.jsf.facesconfig.emf.ManagedBeanClassType
-	 * @generated
-	 */
-	public Adapter createManagedBeanClassTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanNameType <em>Managed Bean Name Type</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.jst.jsf.facesconfig.emf.ManagedBeanNameType
-	 * @generated
-	 */
-	public Adapter createManagedBeanNameTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanScopeType <em>Managed Bean Scope Type</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.jst.jsf.facesconfig.emf.ManagedBeanScopeType
-	 * @generated
-	 */
-	public Adapter createManagedBeanScopeTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanType <em>Managed Bean Type</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.jst.jsf.facesconfig.emf.ManagedBeanType
-	 * @generated
-	 */
-	public Adapter createManagedBeanTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedPropertyType <em>Managed Property Type</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.jst.jsf.facesconfig.emf.ManagedPropertyType
-	 * @generated
-	 */
-	public Adapter createManagedPropertyTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntriesType <em>Map Entries Type</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.jst.jsf.facesconfig.emf.MapEntriesType
-	 * @generated
-	 */
-	public Adapter createMapEntriesTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.MapEntryType <em>Map Entry Type</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.jst.jsf.facesconfig.emf.MapEntryType
-	 * @generated
-	 */
-	public Adapter createMapEntryTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.MessageBundleType <em>Message Bundle Type</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.jst.jsf.facesconfig.emf.MessageBundleType
-	 * @generated
-	 */
-	public Adapter createMessageBundleTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.NameType <em>Name Type</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.jst.jsf.facesconfig.emf.NameType
-	 * @generated
-	 */
-	public Adapter createNameTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationCaseType <em>Navigation Case Type</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.jst.jsf.facesconfig.emf.NavigationCaseType
-	 * @generated
-	 */
-	public Adapter createNavigationCaseTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationHandlerType <em>Navigation Handler Type</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.jst.jsf.facesconfig.emf.NavigationHandlerType
-	 * @generated
-	 */
-	public Adapter createNavigationHandlerTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleType <em>Navigation Rule Type</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.jst.jsf.facesconfig.emf.NavigationRuleType
-	 * @generated
-	 */
-	public Adapter createNavigationRuleTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.NullValueType <em>Null Value Type</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.jst.jsf.facesconfig.emf.NullValueType
-	 * @generated
-	 */
-	public Adapter createNullValueTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.OrderingType <em>Ordering Type</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.jst.jsf.facesconfig.emf.OrderingType
-	 * @generated
-	 */
-	public Adapter createOrderingTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.OrderingOrderingType <em>Ordering Ordering Type</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.jst.jsf.facesconfig.emf.OrderingOrderingType
-	 * @generated
-	 */
-	public Adapter createOrderingOrderingTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.OrderingOthersType <em>Ordering Others Type</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.jst.jsf.facesconfig.emf.OrderingOthersType
-	 * @generated
-	 */
-	public Adapter createOrderingOthersTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.PartialViewContextFactoryType <em>Partial View Context Factory Type</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.jst.jsf.facesconfig.emf.PartialViewContextFactoryType
-	 * @generated
-	 */
-	public Adapter createPartialViewContextFactoryTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.PhaseListenerType <em>Phase Listener Type</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.jst.jsf.facesconfig.emf.PhaseListenerType
-	 * @generated
-	 */
-	public Adapter createPhaseListenerTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyClassType <em>Property Class Type</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.jst.jsf.facesconfig.emf.PropertyClassType
-	 * @generated
-	 */
-	public Adapter createPropertyClassTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyExtensionType <em>Property Extension Type</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.jst.jsf.facesconfig.emf.PropertyExtensionType
-	 * @generated
-	 */
-	public Adapter createPropertyExtensionTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyNameType <em>Property Name Type</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.jst.jsf.facesconfig.emf.PropertyNameType
-	 * @generated
-	 */
-	public Adapter createPropertyNameTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyResolverType <em>Property Resolver Type</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.jst.jsf.facesconfig.emf.PropertyResolverType
-	 * @generated
-	 */
-	public Adapter createPropertyResolverTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.PropertyType <em>Property Type</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.jst.jsf.facesconfig.emf.PropertyType
-	 * @generated
-	 */
-	public Adapter createPropertyTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.RedirectType <em>Redirect Type</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.jst.jsf.facesconfig.emf.RedirectType
-	 * @generated
-	 */
-	public Adapter createRedirectTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.RedirectViewParamType <em>Redirect View Param Type</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.jst.jsf.facesconfig.emf.RedirectViewParamType
-	 * @generated
-	 */
-	public Adapter createRedirectViewParamTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanClassType <em>Referenced Bean Class Type</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.jst.jsf.facesconfig.emf.ReferencedBeanClassType
-	 * @generated
-	 */
-	public Adapter createReferencedBeanClassTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanNameType <em>Referenced Bean Name Type</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.jst.jsf.facesconfig.emf.ReferencedBeanNameType
-	 * @generated
-	 */
-	public Adapter createReferencedBeanNameTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ReferencedBeanType <em>Referenced Bean Type</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.jst.jsf.facesconfig.emf.ReferencedBeanType
-	 * @generated
-	 */
-	public Adapter createReferencedBeanTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererClassType <em>Renderer Class Type</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.jst.jsf.facesconfig.emf.RendererClassType
-	 * @generated
-	 */
-	public Adapter createRendererClassTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererExtensionType <em>Renderer Extension Type</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.jst.jsf.facesconfig.emf.RendererExtensionType
-	 * @generated
-	 */
-	public Adapter createRendererExtensionTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererType <em>Renderer Type</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.jst.jsf.facesconfig.emf.RendererType
-	 * @generated
-	 */
-	public Adapter createRendererTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.RendererTypeType <em>Renderer Type Type</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.jst.jsf.facesconfig.emf.RendererTypeType
-	 * @generated
-	 */
-	public Adapter createRendererTypeTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitClassType <em>Render Kit Class Type</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.jst.jsf.facesconfig.emf.RenderKitClassType
-	 * @generated
-	 */
-	public Adapter createRenderKitClassTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitFactoryType <em>Render Kit Factory Type</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.jst.jsf.facesconfig.emf.RenderKitFactoryType
-	 * @generated
-	 */
-	public Adapter createRenderKitFactoryTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitIdType <em>Render Kit Id Type</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.jst.jsf.facesconfig.emf.RenderKitIdType
-	 * @generated
-	 */
-	public Adapter createRenderKitIdTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitType <em>Render Kit Type</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.jst.jsf.facesconfig.emf.RenderKitType
-	 * @generated
-	 */
-	public Adapter createRenderKitTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.SmallIconType <em>Small Icon Type</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.jst.jsf.facesconfig.emf.SmallIconType
-	 * @generated
-	 */
-	public Adapter createSmallIconTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.SourceClassType <em>Source Class Type</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.jst.jsf.facesconfig.emf.SourceClassType
-	 * @generated
-	 */
-	public Adapter createSourceClassTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.StateManagerType <em>State Manager Type</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.jst.jsf.facesconfig.emf.StateManagerType
-	 * @generated
-	 */
-	public Adapter createStateManagerTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.SuggestedValueType <em>Suggested Value Type</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.jst.jsf.facesconfig.emf.SuggestedValueType
-	 * @generated
-	 */
-	public Adapter createSuggestedValueTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.SupportedLocaleType <em>Supported Locale Type</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.jst.jsf.facesconfig.emf.SupportedLocaleType
-	 * @generated
-	 */
-	public Adapter createSupportedLocaleTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventClassType <em>System Event Class Type</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.jst.jsf.facesconfig.emf.SystemEventClassType
-	 * @generated
-	 */
-	public Adapter createSystemEventClassTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerClassType <em>System Event Listener Class Type</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.jst.jsf.facesconfig.emf.SystemEventListenerClassType
-	 * @generated
-	 */
-	public Adapter createSystemEventListenerClassTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.SystemEventListenerType <em>System Event Listener Type</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.jst.jsf.facesconfig.emf.SystemEventListenerType
-	 * @generated
-	 */
-	public Adapter createSystemEventListenerTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.TagHandlerDelegateFactoryType <em>Tag Handler Delegate Factory Type</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.jst.jsf.facesconfig.emf.TagHandlerDelegateFactoryType
-	 * @generated
-	 */
-	public Adapter createTagHandlerDelegateFactoryTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ToViewIdType <em>To View Id Type</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.jst.jsf.facesconfig.emf.ToViewIdType
-	 * @generated
-	 */
-	public Adapter createToViewIdTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorClassType <em>Validator Class Type</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.jst.jsf.facesconfig.emf.ValidatorClassType
-	 * @generated
-	 */
-	public Adapter createValidatorClassTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorIdType <em>Validator Id Type</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.jst.jsf.facesconfig.emf.ValidatorIdType
-	 * @generated
-	 */
-	public Adapter createValidatorIdTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorType <em>Validator Type</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.jst.jsf.facesconfig.emf.ValidatorType
-	 * @generated
-	 */
-	public Adapter createValidatorTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ValueClassType <em>Value Class Type</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.jst.jsf.facesconfig.emf.ValueClassType
-	 * @generated
-	 */
-	public Adapter createValueClassTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ValueType <em>Value Type</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.jst.jsf.facesconfig.emf.ValueType
-	 * @generated
-	 */
-	public Adapter createValueTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.VariableResolverType <em>Variable Resolver Type</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.jst.jsf.facesconfig.emf.VariableResolverType
-	 * @generated
-	 */
-	public Adapter createVariableResolverTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ViewHandlerType <em>View Handler Type</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.jst.jsf.facesconfig.emf.ViewHandlerType
-	 * @generated
-	 */
-	public Adapter createViewHandlerTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceBundleType <em>Resource Bundle Type</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.jst.jsf.facesconfig.emf.ResourceBundleType
-	 * @generated
-	 */
-    public Adapter createResourceBundleTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.BaseNameType <em>Base Name Type</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.jst.jsf.facesconfig.emf.BaseNameType
-	 * @generated
-	 */
-    public Adapter createBaseNameTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.VarType <em>Var Type</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.jst.jsf.facesconfig.emf.VarType
-	 * @generated
-	 */
-    public Adapter createVarTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ViewDeclarationLanguageFactoryType <em>View Declaration Language Factory Type</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.jst.jsf.facesconfig.emf.ViewDeclarationLanguageFactoryType
-	 * @generated
-	 */
-	public Adapter createViewDeclarationLanguageFactoryTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.VisitContextFactoryType <em>Visit Context Factory Type</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.jst.jsf.facesconfig.emf.VisitContextFactoryType
-	 * @generated
-	 */
-	public Adapter createVisitContextFactoryTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.RenderKitExtensionType <em>Render Kit Extension Type</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.jst.jsf.facesconfig.emf.RenderKitExtensionType
-	 * @generated
-	 */
-    public Adapter createRenderKitExtensionTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ResourceHandlerType <em>Resource Handler Type</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.jst.jsf.facesconfig.emf.ResourceHandlerType
-	 * @generated
-	 */
-	public Adapter createResourceHandlerTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.NavigationRuleExtensionType <em>Navigation Rule Extension Type</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.jst.jsf.facesconfig.emf.NavigationRuleExtensionType
-	 * @generated
-	 */
-    public Adapter createNavigationRuleExtensionTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ValidatorExtensionType <em>Validator Extension Type</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.jst.jsf.facesconfig.emf.ValidatorExtensionType
-	 * @generated
-	 */
-    public Adapter createValidatorExtensionTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.FacesConfigExtensionType <em>Extension Type</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.jst.jsf.facesconfig.emf.FacesConfigExtensionType
-	 * @generated
-	 */
-    public Adapter createFacesConfigExtensionTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.FactoryExtensionType <em>Factory Extension Type</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.jst.jsf.facesconfig.emf.FactoryExtensionType
-	 * @generated
-	 */
-    public Adapter createFactoryExtensionTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.LifecycleExtensionType <em>Lifecycle Extension Type</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.jst.jsf.facesconfig.emf.LifecycleExtensionType
-	 * @generated
-	 */
-    public Adapter createLifecycleExtensionTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ManagedBeanExtensionType <em>Managed Bean Extension Type</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.jst.jsf.facesconfig.emf.ManagedBeanExtensionType
-	 * @generated
-	 */
-    public Adapter createManagedBeanExtensionTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ConverterExtensionType <em>Converter Extension Type</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.jst.jsf.facesconfig.emf.ConverterExtensionType
-	 * @generated
-	 */
-    public Adapter createConverterExtensionTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ExtensionType <em>Extension Type</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.jst.jsf.facesconfig.emf.ExtensionType
-	 * @generated
-	 */
-    public Adapter createExtensionTypeAdapter() {
-		return null;
-	}
-
-    /**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ExternalContextFactoryType <em>External Context Factory Type</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.jst.jsf.facesconfig.emf.ExternalContextFactoryType
-	 * @generated
-	 */
-	public Adapter createExternalContextFactoryTypeAdapter() {
-		return null;
-	}
-
-				/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facesconfig.emf.ApplicationExtensionType <em>Application Extension Type</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.jst.jsf.facesconfig.emf.ApplicationExtensionType
-	 * @generated
-	 */
-    public Adapter createApplicationExtensionTypeAdapter() {
-		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;
-	}
-
-} //FacesConfigAdapterFactory
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/util/FacesConfigSwitch.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/util/FacesConfigSwitch.java
deleted file mode 100644
index 1b258f5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/util/FacesConfigSwitch.java
+++ /dev/null
@@ -1,2722 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.emf.util;
-
-import java.util.List;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.jst.jsf.facesconfig.emf.*;
-
-
-/**
- * <!-- 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.jst.jsf.facesconfig.emf.FacesConfigPackage
- * @generated
- */
-public class FacesConfigSwitch {
-    /**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static final String copyright = "Copyright (c) 2005, 2006 IBM Corporation and others"; //$NON-NLS-1$
-
-    /**
-	 * The cached model package
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected static FacesConfigPackage modelPackage;
-
-    /**
-	 * Creates an instance of the switch.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public FacesConfigSwitch() {
-		if (modelPackage == null) {
-			modelPackage = FacesConfigPackage.eINSTANCE;
-		}
-	}
-
-    /**
-	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
-	 * <!-- begin-user-doc -->
-     * @param theEObject 
-     * @return the first non-null result returned by a <code>caseXXX</code> call.
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public Object doSwitch(EObject theEObject) {
-		return doSwitch(theEObject.eClass(), theEObject);
-	}
-
-    /**
-	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
-	 * <!-- begin-user-doc -->
-     * @param theEClass 
-     * @param theEObject 
-     * @return the first non-null result returned by a <code>caseXXX</code> call.
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	protected Object doSwitch(EClass theEClass, EObject theEObject) {
-		if (theEClass.eContainer() == modelPackage) {
-			return doSwitch(theEClass.getClassifierID(), theEObject);
-		}
-		List eSuperTypes = theEClass.getESuperTypes();
-		return
-			eSuperTypes.isEmpty() ?
-				defaultCase(theEObject) :
-				doSwitch((EClass)eSuperTypes.get(0), theEObject);
-	}
-
-    /**
-	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
-	 * <!-- begin-user-doc -->
-     * @param classifierID 
-     * @param theEObject 
-	 * <!-- end-user-doc -->
-	 * @return the first non-null result returned by a <code>caseXXX</code> call.
-	 * @generated
-	 */
-	protected Object doSwitch(int classifierID, EObject theEObject) {
-		switch (classifierID) {
-			case FacesConfigPackage.ABSOLUTE_ORDERING_TYPE: {
-				AbsoluteOrderingType absoluteOrderingType = (AbsoluteOrderingType)theEObject;
-				Object result = caseAbsoluteOrderingType(absoluteOrderingType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.ACTION_LISTENER_TYPE: {
-				ActionListenerType actionListenerType = (ActionListenerType)theEObject;
-				Object result = caseActionListenerType(actionListenerType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.APPLICATION_FACTORY_TYPE: {
-				ApplicationFactoryType applicationFactoryType = (ApplicationFactoryType)theEObject;
-				Object result = caseApplicationFactoryType(applicationFactoryType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.APPLICATION_TYPE: {
-				ApplicationType applicationType = (ApplicationType)theEObject;
-				Object result = caseApplicationType(applicationType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.APPLICATION_EXTENSION_TYPE: {
-				ApplicationExtensionType applicationExtensionType = (ApplicationExtensionType)theEObject;
-				Object result = caseApplicationExtensionType(applicationExtensionType);
-				if (result == null) result = caseExtensionType(applicationExtensionType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.ATTRIBUTE_CLASS_TYPE: {
-				AttributeClassType attributeClassType = (AttributeClassType)theEObject;
-				Object result = caseAttributeClassType(attributeClassType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.ATTRIBUTE_EXTENSION_TYPE: {
-				AttributeExtensionType attributeExtensionType = (AttributeExtensionType)theEObject;
-				Object result = caseAttributeExtensionType(attributeExtensionType);
-				if (result == null) result = caseExtensionType(attributeExtensionType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.ATTRIBUTE_NAME_TYPE: {
-				AttributeNameType attributeNameType = (AttributeNameType)theEObject;
-				Object result = caseAttributeNameType(attributeNameType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.ATTRIBUTE_TYPE: {
-				AttributeType attributeType = (AttributeType)theEObject;
-				Object result = caseAttributeType(attributeType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.BEHAVIOR_CLASS_TYPE: {
-				BehaviorClassType behaviorClassType = (BehaviorClassType)theEObject;
-				Object result = caseBehaviorClassType(behaviorClassType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.BEHAVIOR_ID_TYPE: {
-				BehaviorIdType behaviorIdType = (BehaviorIdType)theEObject;
-				Object result = caseBehaviorIdType(behaviorIdType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.BEHAVIOR_TYPE: {
-				BehaviorType behaviorType = (BehaviorType)theEObject;
-				Object result = caseBehaviorType(behaviorType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.BEHAVIOR_EXTENSION_TYPE: {
-				BehaviorExtensionType behaviorExtensionType = (BehaviorExtensionType)theEObject;
-				Object result = caseBehaviorExtensionType(behaviorExtensionType);
-				if (result == null) result = caseExtensionType(behaviorExtensionType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_CLASS_TYPE: {
-				ClientBehaviorRendererClassType clientBehaviorRendererClassType = (ClientBehaviorRendererClassType)theEObject;
-				Object result = caseClientBehaviorRendererClassType(clientBehaviorRendererClassType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE: {
-				ClientBehaviorRendererType clientBehaviorRendererType = (ClientBehaviorRendererType)theEObject;
-				Object result = caseClientBehaviorRendererType(clientBehaviorRendererType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.CLIENT_BEHAVIOR_RENDERER_TYPE_TYPE: {
-				ClientBehaviorRendererTypeType clientBehaviorRendererTypeType = (ClientBehaviorRendererTypeType)theEObject;
-				Object result = caseClientBehaviorRendererTypeType(clientBehaviorRendererTypeType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.COMPONENT_CLASS_TYPE: {
-				ComponentClassType componentClassType = (ComponentClassType)theEObject;
-				Object result = caseComponentClassType(componentClassType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.COMPONENT_EXTENSION_TYPE: {
-				ComponentExtensionType componentExtensionType = (ComponentExtensionType)theEObject;
-				Object result = caseComponentExtensionType(componentExtensionType);
-				if (result == null) result = caseExtensionType(componentExtensionType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.COMPONENT_FAMILY_TYPE: {
-				ComponentFamilyType componentFamilyType = (ComponentFamilyType)theEObject;
-				Object result = caseComponentFamilyType(componentFamilyType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.COMPONENT_TYPE: {
-				ComponentType componentType = (ComponentType)theEObject;
-				Object result = caseComponentType(componentType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.COMPONENT_TYPE_TYPE: {
-				ComponentTypeType componentTypeType = (ComponentTypeType)theEObject;
-				Object result = caseComponentTypeType(componentTypeType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.CONVERTER_CLASS_TYPE: {
-				ConverterClassType converterClassType = (ConverterClassType)theEObject;
-				Object result = caseConverterClassType(converterClassType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.CONVERTER_FOR_CLASS_TYPE: {
-				ConverterForClassType converterForClassType = (ConverterForClassType)theEObject;
-				Object result = caseConverterForClassType(converterForClassType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.CONVERTER_ID_TYPE: {
-				ConverterIdType converterIdType = (ConverterIdType)theEObject;
-				Object result = caseConverterIdType(converterIdType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.CONVERTER_TYPE: {
-				ConverterType converterType = (ConverterType)theEObject;
-				Object result = caseConverterType(converterType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.CONVERTER_EXTENSION_TYPE: {
-				ConverterExtensionType converterExtensionType = (ConverterExtensionType)theEObject;
-				Object result = caseConverterExtensionType(converterExtensionType);
-				if (result == null) result = caseExtensionType(converterExtensionType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.DEFAULT_LOCALE_TYPE: {
-				DefaultLocaleType defaultLocaleType = (DefaultLocaleType)theEObject;
-				Object result = caseDefaultLocaleType(defaultLocaleType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.DEFAULT_RENDER_KIT_ID_TYPE: {
-				DefaultRenderKitIdType defaultRenderKitIdType = (DefaultRenderKitIdType)theEObject;
-				Object result = caseDefaultRenderKitIdType(defaultRenderKitIdType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.DEFAULT_VALIDATORS_TYPE: {
-				DefaultValidatorsType defaultValidatorsType = (DefaultValidatorsType)theEObject;
-				Object result = caseDefaultValidatorsType(defaultValidatorsType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.DEFAULT_VALUE_TYPE: {
-				DefaultValueType defaultValueType = (DefaultValueType)theEObject;
-				Object result = caseDefaultValueType(defaultValueType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.DESCRIPTION_TYPE: {
-				DescriptionType descriptionType = (DescriptionType)theEObject;
-				Object result = caseDescriptionType(descriptionType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.DISPLAY_NAME_TYPE: {
-				DisplayNameType displayNameType = (DisplayNameType)theEObject;
-				Object result = caseDisplayNameType(displayNameType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.DOCUMENT_ROOT: {
-				DocumentRoot documentRoot = (DocumentRoot)theEObject;
-				Object result = caseDocumentRoot(documentRoot);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.DYNAMIC_ATTRIBUTE: {
-				DynamicAttribute dynamicAttribute = (DynamicAttribute)theEObject;
-				Object result = caseDynamicAttribute(dynamicAttribute);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.DYNAMIC_ELEMENT: {
-				DynamicElement dynamicElement = (DynamicElement)theEObject;
-				Object result = caseDynamicElement(dynamicElement);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.EL_RESOLVER_TYPE: {
-				ELResolverType elResolverType = (ELResolverType)theEObject;
-				Object result = caseELResolverType(elResolverType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.EXCEPTION_HANDLER_FACTORY_TYPE: {
-				ExceptionHandlerFactoryType exceptionHandlerFactoryType = (ExceptionHandlerFactoryType)theEObject;
-				Object result = caseExceptionHandlerFactoryType(exceptionHandlerFactoryType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.EXTENSION_TYPE: {
-				ExtensionType extensionType = (ExtensionType)theEObject;
-				Object result = caseExtensionType(extensionType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.EXTERNAL_CONTEXT_FACTORY_TYPE: {
-				ExternalContextFactoryType externalContextFactoryType = (ExternalContextFactoryType)theEObject;
-				Object result = caseExternalContextFactoryType(externalContextFactoryType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.FACES_CONFIG_TYPE: {
-				FacesConfigType facesConfigType = (FacesConfigType)theEObject;
-				Object result = caseFacesConfigType(facesConfigType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.FACES_CONFIG_EXTENSION_TYPE: {
-				FacesConfigExtensionType facesConfigExtensionType = (FacesConfigExtensionType)theEObject;
-				Object result = caseFacesConfigExtensionType(facesConfigExtensionType);
-				if (result == null) result = caseExtensionType(facesConfigExtensionType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.FACES_CONTEXT_FACTORY_TYPE: {
-				FacesContextFactoryType facesContextFactoryType = (FacesContextFactoryType)theEObject;
-				Object result = caseFacesContextFactoryType(facesContextFactoryType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.FACET_EXTENSION_TYPE: {
-				FacetExtensionType facetExtensionType = (FacetExtensionType)theEObject;
-				Object result = caseFacetExtensionType(facetExtensionType);
-				if (result == null) result = caseExtensionType(facetExtensionType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.FACET_NAME_TYPE: {
-				FacetNameType facetNameType = (FacetNameType)theEObject;
-				Object result = caseFacetNameType(facetNameType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.FACET_TYPE: {
-				FacetType facetType = (FacetType)theEObject;
-				Object result = caseFacetType(facetType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.FACTORY_TYPE: {
-				FactoryType factoryType = (FactoryType)theEObject;
-				Object result = caseFactoryType(factoryType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.FACTORY_EXTENSION_TYPE: {
-				FactoryExtensionType factoryExtensionType = (FactoryExtensionType)theEObject;
-				Object result = caseFactoryExtensionType(factoryExtensionType);
-				if (result == null) result = caseExtensionType(factoryExtensionType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.FROM_ACTION_TYPE: {
-				FromActionType fromActionType = (FromActionType)theEObject;
-				Object result = caseFromActionType(fromActionType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.FROM_OUTCOME_TYPE: {
-				FromOutcomeType fromOutcomeType = (FromOutcomeType)theEObject;
-				Object result = caseFromOutcomeType(fromOutcomeType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.FROM_VIEW_ID_TYPE: {
-				FromViewIdType fromViewIdType = (FromViewIdType)theEObject;
-				Object result = caseFromViewIdType(fromViewIdType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.ICON_TYPE: {
-				IconType iconType = (IconType)theEObject;
-				Object result = caseIconType(iconType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.IF_TYPE: {
-				IfType ifType = (IfType)theEObject;
-				Object result = caseIfType(ifType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.KEY_CLASS_TYPE: {
-				KeyClassType keyClassType = (KeyClassType)theEObject;
-				Object result = caseKeyClassType(keyClassType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.KEY_TYPE: {
-				KeyType keyType = (KeyType)theEObject;
-				Object result = caseKeyType(keyType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.LARGE_ICON_TYPE: {
-				LargeIconType largeIconType = (LargeIconType)theEObject;
-				Object result = caseLargeIconType(largeIconType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.LIFECYCLE_FACTORY_TYPE: {
-				LifecycleFactoryType lifecycleFactoryType = (LifecycleFactoryType)theEObject;
-				Object result = caseLifecycleFactoryType(lifecycleFactoryType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.LIFECYCLE_TYPE: {
-				LifecycleType lifecycleType = (LifecycleType)theEObject;
-				Object result = caseLifecycleType(lifecycleType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.LIFECYCLE_EXTENSION_TYPE: {
-				LifecycleExtensionType lifecycleExtensionType = (LifecycleExtensionType)theEObject;
-				Object result = caseLifecycleExtensionType(lifecycleExtensionType);
-				if (result == null) result = caseExtensionType(lifecycleExtensionType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.LIST_ENTRIES_TYPE: {
-				ListEntriesType listEntriesType = (ListEntriesType)theEObject;
-				Object result = caseListEntriesType(listEntriesType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.LOCALE_CONFIG_TYPE: {
-				LocaleConfigType localeConfigType = (LocaleConfigType)theEObject;
-				Object result = caseLocaleConfigType(localeConfigType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.MANAGED_BEAN_CLASS_TYPE: {
-				ManagedBeanClassType managedBeanClassType = (ManagedBeanClassType)theEObject;
-				Object result = caseManagedBeanClassType(managedBeanClassType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.MANAGED_BEAN_NAME_TYPE: {
-				ManagedBeanNameType managedBeanNameType = (ManagedBeanNameType)theEObject;
-				Object result = caseManagedBeanNameType(managedBeanNameType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.MANAGED_BEAN_SCOPE_TYPE: {
-				ManagedBeanScopeType managedBeanScopeType = (ManagedBeanScopeType)theEObject;
-				Object result = caseManagedBeanScopeType(managedBeanScopeType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.MANAGED_BEAN_TYPE: {
-				ManagedBeanType managedBeanType = (ManagedBeanType)theEObject;
-				Object result = caseManagedBeanType(managedBeanType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.MANAGED_BEAN_EXTENSION_TYPE: {
-				ManagedBeanExtensionType managedBeanExtensionType = (ManagedBeanExtensionType)theEObject;
-				Object result = caseManagedBeanExtensionType(managedBeanExtensionType);
-				if (result == null) result = caseExtensionType(managedBeanExtensionType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.MANAGED_PROPERTY_TYPE: {
-				ManagedPropertyType managedPropertyType = (ManagedPropertyType)theEObject;
-				Object result = caseManagedPropertyType(managedPropertyType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.MAP_ENTRIES_TYPE: {
-				MapEntriesType mapEntriesType = (MapEntriesType)theEObject;
-				Object result = caseMapEntriesType(mapEntriesType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.MAP_ENTRY_TYPE: {
-				MapEntryType mapEntryType = (MapEntryType)theEObject;
-				Object result = caseMapEntryType(mapEntryType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.MESSAGE_BUNDLE_TYPE: {
-				MessageBundleType messageBundleType = (MessageBundleType)theEObject;
-				Object result = caseMessageBundleType(messageBundleType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.NAME_TYPE: {
-				NameType nameType = (NameType)theEObject;
-				Object result = caseNameType(nameType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.NAVIGATION_CASE_TYPE: {
-				NavigationCaseType navigationCaseType = (NavigationCaseType)theEObject;
-				Object result = caseNavigationCaseType(navigationCaseType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.NAVIGATION_HANDLER_TYPE: {
-				NavigationHandlerType navigationHandlerType = (NavigationHandlerType)theEObject;
-				Object result = caseNavigationHandlerType(navigationHandlerType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.NAVIGATION_RULE_TYPE: {
-				NavigationRuleType navigationRuleType = (NavigationRuleType)theEObject;
-				Object result = caseNavigationRuleType(navigationRuleType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.NAVIGATION_RULE_EXTENSION_TYPE: {
-				NavigationRuleExtensionType navigationRuleExtensionType = (NavigationRuleExtensionType)theEObject;
-				Object result = caseNavigationRuleExtensionType(navigationRuleExtensionType);
-				if (result == null) result = caseExtensionType(navigationRuleExtensionType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.NULL_VALUE_TYPE: {
-				NullValueType nullValueType = (NullValueType)theEObject;
-				Object result = caseNullValueType(nullValueType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.ORDERING_TYPE: {
-				OrderingType orderingType = (OrderingType)theEObject;
-				Object result = caseOrderingType(orderingType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.ORDERING_ORDERING_TYPE: {
-				OrderingOrderingType orderingOrderingType = (OrderingOrderingType)theEObject;
-				Object result = caseOrderingOrderingType(orderingOrderingType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.ORDERING_OTHERS_TYPE: {
-				OrderingOthersType orderingOthersType = (OrderingOthersType)theEObject;
-				Object result = caseOrderingOthersType(orderingOthersType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.PARTIAL_VIEW_CONTEXT_FACTORY_TYPE: {
-				PartialViewContextFactoryType partialViewContextFactoryType = (PartialViewContextFactoryType)theEObject;
-				Object result = casePartialViewContextFactoryType(partialViewContextFactoryType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.PHASE_LISTENER_TYPE: {
-				PhaseListenerType phaseListenerType = (PhaseListenerType)theEObject;
-				Object result = casePhaseListenerType(phaseListenerType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.PROPERTY_CLASS_TYPE: {
-				PropertyClassType propertyClassType = (PropertyClassType)theEObject;
-				Object result = casePropertyClassType(propertyClassType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.PROPERTY_EXTENSION_TYPE: {
-				PropertyExtensionType propertyExtensionType = (PropertyExtensionType)theEObject;
-				Object result = casePropertyExtensionType(propertyExtensionType);
-				if (result == null) result = caseExtensionType(propertyExtensionType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.PROPERTY_NAME_TYPE: {
-				PropertyNameType propertyNameType = (PropertyNameType)theEObject;
-				Object result = casePropertyNameType(propertyNameType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.PROPERTY_RESOLVER_TYPE: {
-				PropertyResolverType propertyResolverType = (PropertyResolverType)theEObject;
-				Object result = casePropertyResolverType(propertyResolverType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.PROPERTY_TYPE: {
-				PropertyType propertyType = (PropertyType)theEObject;
-				Object result = casePropertyType(propertyType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.REDIRECT_TYPE: {
-				RedirectType redirectType = (RedirectType)theEObject;
-				Object result = caseRedirectType(redirectType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.REDIRECT_VIEW_PARAM_TYPE: {
-				RedirectViewParamType redirectViewParamType = (RedirectViewParamType)theEObject;
-				Object result = caseRedirectViewParamType(redirectViewParamType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.REFERENCED_BEAN_CLASS_TYPE: {
-				ReferencedBeanClassType referencedBeanClassType = (ReferencedBeanClassType)theEObject;
-				Object result = caseReferencedBeanClassType(referencedBeanClassType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.REFERENCED_BEAN_NAME_TYPE: {
-				ReferencedBeanNameType referencedBeanNameType = (ReferencedBeanNameType)theEObject;
-				Object result = caseReferencedBeanNameType(referencedBeanNameType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.REFERENCED_BEAN_TYPE: {
-				ReferencedBeanType referencedBeanType = (ReferencedBeanType)theEObject;
-				Object result = caseReferencedBeanType(referencedBeanType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.RENDERER_CLASS_TYPE: {
-				RendererClassType rendererClassType = (RendererClassType)theEObject;
-				Object result = caseRendererClassType(rendererClassType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.RENDERER_EXTENSION_TYPE: {
-				RendererExtensionType rendererExtensionType = (RendererExtensionType)theEObject;
-				Object result = caseRendererExtensionType(rendererExtensionType);
-				if (result == null) result = caseExtensionType(rendererExtensionType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.RENDERER_TYPE: {
-				RendererType rendererType = (RendererType)theEObject;
-				Object result = caseRendererType(rendererType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.RENDERER_TYPE_TYPE: {
-				RendererTypeType rendererTypeType = (RendererTypeType)theEObject;
-				Object result = caseRendererTypeType(rendererTypeType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.RENDER_KIT_CLASS_TYPE: {
-				RenderKitClassType renderKitClassType = (RenderKitClassType)theEObject;
-				Object result = caseRenderKitClassType(renderKitClassType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.RENDER_KIT_FACTORY_TYPE: {
-				RenderKitFactoryType renderKitFactoryType = (RenderKitFactoryType)theEObject;
-				Object result = caseRenderKitFactoryType(renderKitFactoryType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.RENDER_KIT_ID_TYPE: {
-				RenderKitIdType renderKitIdType = (RenderKitIdType)theEObject;
-				Object result = caseRenderKitIdType(renderKitIdType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.RENDER_KIT_TYPE: {
-				RenderKitType renderKitType = (RenderKitType)theEObject;
-				Object result = caseRenderKitType(renderKitType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.RENDER_KIT_EXTENSION_TYPE: {
-				RenderKitExtensionType renderKitExtensionType = (RenderKitExtensionType)theEObject;
-				Object result = caseRenderKitExtensionType(renderKitExtensionType);
-				if (result == null) result = caseExtensionType(renderKitExtensionType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.RESOURCE_HANDLER_TYPE: {
-				ResourceHandlerType resourceHandlerType = (ResourceHandlerType)theEObject;
-				Object result = caseResourceHandlerType(resourceHandlerType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.SMALL_ICON_TYPE: {
-				SmallIconType smallIconType = (SmallIconType)theEObject;
-				Object result = caseSmallIconType(smallIconType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.SOURCE_CLASS_TYPE: {
-				SourceClassType sourceClassType = (SourceClassType)theEObject;
-				Object result = caseSourceClassType(sourceClassType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.STATE_MANAGER_TYPE: {
-				StateManagerType stateManagerType = (StateManagerType)theEObject;
-				Object result = caseStateManagerType(stateManagerType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.SUGGESTED_VALUE_TYPE: {
-				SuggestedValueType suggestedValueType = (SuggestedValueType)theEObject;
-				Object result = caseSuggestedValueType(suggestedValueType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.SUPPORTED_LOCALE_TYPE: {
-				SupportedLocaleType supportedLocaleType = (SupportedLocaleType)theEObject;
-				Object result = caseSupportedLocaleType(supportedLocaleType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.SYSTEM_EVENT_CLASS_TYPE: {
-				SystemEventClassType systemEventClassType = (SystemEventClassType)theEObject;
-				Object result = caseSystemEventClassType(systemEventClassType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_CLASS_TYPE: {
-				SystemEventListenerClassType systemEventListenerClassType = (SystemEventListenerClassType)theEObject;
-				Object result = caseSystemEventListenerClassType(systemEventListenerClassType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.SYSTEM_EVENT_LISTENER_TYPE: {
-				SystemEventListenerType systemEventListenerType = (SystemEventListenerType)theEObject;
-				Object result = caseSystemEventListenerType(systemEventListenerType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.TAG_HANDLER_DELEGATE_FACTORY_TYPE: {
-				TagHandlerDelegateFactoryType tagHandlerDelegateFactoryType = (TagHandlerDelegateFactoryType)theEObject;
-				Object result = caseTagHandlerDelegateFactoryType(tagHandlerDelegateFactoryType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.TO_VIEW_ID_TYPE: {
-				ToViewIdType toViewIdType = (ToViewIdType)theEObject;
-				Object result = caseToViewIdType(toViewIdType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.VALIDATOR_CLASS_TYPE: {
-				ValidatorClassType validatorClassType = (ValidatorClassType)theEObject;
-				Object result = caseValidatorClassType(validatorClassType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.VALIDATOR_ID_TYPE: {
-				ValidatorIdType validatorIdType = (ValidatorIdType)theEObject;
-				Object result = caseValidatorIdType(validatorIdType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.VALIDATOR_TYPE: {
-				ValidatorType validatorType = (ValidatorType)theEObject;
-				Object result = caseValidatorType(validatorType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.VALIDATOR_EXTENSION_TYPE: {
-				ValidatorExtensionType validatorExtensionType = (ValidatorExtensionType)theEObject;
-				Object result = caseValidatorExtensionType(validatorExtensionType);
-				if (result == null) result = caseExtensionType(validatorExtensionType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.VALUE_CLASS_TYPE: {
-				ValueClassType valueClassType = (ValueClassType)theEObject;
-				Object result = caseValueClassType(valueClassType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.VALUE_TYPE: {
-				ValueType valueType = (ValueType)theEObject;
-				Object result = caseValueType(valueType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.VARIABLE_RESOLVER_TYPE: {
-				VariableResolverType variableResolverType = (VariableResolverType)theEObject;
-				Object result = caseVariableResolverType(variableResolverType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.VIEW_HANDLER_TYPE: {
-				ViewHandlerType viewHandlerType = (ViewHandlerType)theEObject;
-				Object result = caseViewHandlerType(viewHandlerType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.RESOURCE_BUNDLE_TYPE: {
-				ResourceBundleType resourceBundleType = (ResourceBundleType)theEObject;
-				Object result = caseResourceBundleType(resourceBundleType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.BASE_NAME_TYPE: {
-				BaseNameType baseNameType = (BaseNameType)theEObject;
-				Object result = caseBaseNameType(baseNameType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.VAR_TYPE: {
-				VarType varType = (VarType)theEObject;
-				Object result = caseVarType(varType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.VIEW_DECLARATION_LANGUAGE_FACTORY_TYPE: {
-				ViewDeclarationLanguageFactoryType viewDeclarationLanguageFactoryType = (ViewDeclarationLanguageFactoryType)theEObject;
-				Object result = caseViewDeclarationLanguageFactoryType(viewDeclarationLanguageFactoryType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case FacesConfigPackage.VISIT_CONTEXT_FACTORY_TYPE: {
-				VisitContextFactoryType visitContextFactoryType = (VisitContextFactoryType)theEObject;
-				Object result = caseVisitContextFactoryType(visitContextFactoryType);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			default: return defaultCase(theEObject);
-		}
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Absolute Ordering Type</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>Absolute Ordering Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseAbsoluteOrderingType(AbsoluteOrderingType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Action Listener Type</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>Action Listener Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseActionListenerType(ActionListenerType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Application Factory Type</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>Application Factory Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseApplicationFactoryType(ApplicationFactoryType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Application Type</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>Application Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseApplicationType(ApplicationType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Attribute Class Type</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>Attribute Class Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseAttributeClassType(AttributeClassType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Attribute Extension Type</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>Attribute Extension Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseAttributeExtensionType(AttributeExtensionType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Attribute Name Type</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>Attribute Name Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseAttributeNameType(AttributeNameType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Attribute Type</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>Attribute Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseAttributeType(AttributeType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Behavior Class Type</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>Behavior Class Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseBehaviorClassType(BehaviorClassType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Behavior Id Type</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>Behavior Id Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseBehaviorIdType(BehaviorIdType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Behavior Type</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>Behavior Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseBehaviorType(BehaviorType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Behavior Extension Type</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>Behavior Extension Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseBehaviorExtensionType(BehaviorExtensionType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Client Behavior Renderer Class Type</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>Client Behavior Renderer Class Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseClientBehaviorRendererClassType(ClientBehaviorRendererClassType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Client Behavior Renderer Type</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>Client Behavior Renderer Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseClientBehaviorRendererType(ClientBehaviorRendererType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Client Behavior Renderer Type Type</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>Client Behavior Renderer Type Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseClientBehaviorRendererTypeType(ClientBehaviorRendererTypeType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Component Class Type</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>Component Class Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseComponentClassType(ComponentClassType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Component Extension Type</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>Component Extension Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseComponentExtensionType(ComponentExtensionType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Component Family Type</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>Component Family Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseComponentFamilyType(ComponentFamilyType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Component Type</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>Component Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseComponentType(ComponentType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Component Type Type</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>Component Type Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseComponentTypeType(ComponentTypeType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Converter Class Type</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>Converter Class Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseConverterClassType(ConverterClassType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Converter For Class Type</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>Converter For Class Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseConverterForClassType(ConverterForClassType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Converter Id Type</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>Converter Id Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseConverterIdType(ConverterIdType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Converter Type</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>Converter Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseConverterType(ConverterType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Default Locale Type</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>Default Locale Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseDefaultLocaleType(DefaultLocaleType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Default Render Kit Id Type</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>Default Render Kit Id Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseDefaultRenderKitIdType(DefaultRenderKitIdType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Default Validators Type</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>Default Validators Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseDefaultValidatorsType(DefaultValidatorsType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Default Value Type</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>Default Value Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseDefaultValueType(DefaultValueType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Description Type</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>Description Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseDescriptionType(DescriptionType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Display Name Type</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>Display Name Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseDisplayNameType(DisplayNameType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Document Root</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>Document Root</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseDocumentRoot(DocumentRoot object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Dynamic Attribute</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>Dynamic Attribute</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-    public Object caseDynamicAttribute(DynamicAttribute object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Dynamic 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>Dynamic Element</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-    public Object caseDynamicElement(DynamicElement object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>EL Resolver Type</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>EL Resolver Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-    public Object caseELResolverType(ELResolverType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Exception Handler Factory Type</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>Exception Handler Factory Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseExceptionHandlerFactoryType(ExceptionHandlerFactoryType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Type</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>Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseFacesConfigType(FacesConfigType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Faces Context Factory Type</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>Faces Context Factory Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseFacesContextFactoryType(FacesContextFactoryType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Facet Extension Type</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>Facet Extension Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseFacetExtensionType(FacetExtensionType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Facet Name Type</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>Facet Name Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseFacetNameType(FacetNameType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Facet Type</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>Facet Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseFacetType(FacetType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Factory Type</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>Factory Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseFactoryType(FactoryType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>From Action Type</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>From Action Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseFromActionType(FromActionType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>From Outcome Type</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>From Outcome Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseFromOutcomeType(FromOutcomeType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>From View Id Type</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>From View Id Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseFromViewIdType(FromViewIdType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Icon Type</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>Icon Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseIconType(IconType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>If Type</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>If Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseIfType(IfType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Key Class Type</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>Key Class Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseKeyClassType(KeyClassType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Key Type</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>Key Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseKeyType(KeyType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Large Icon Type</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>Large Icon Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseLargeIconType(LargeIconType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Lifecycle Factory Type</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>Lifecycle Factory Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseLifecycleFactoryType(LifecycleFactoryType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Lifecycle Type</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>Lifecycle Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseLifecycleType(LifecycleType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>List Entries Type</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>List Entries Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseListEntriesType(ListEntriesType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Locale Config Type</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>Locale Config Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseLocaleConfigType(LocaleConfigType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Managed Bean Class Type</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>Managed Bean Class Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseManagedBeanClassType(ManagedBeanClassType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Managed Bean Name Type</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>Managed Bean Name Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseManagedBeanNameType(ManagedBeanNameType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Managed Bean Scope Type</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>Managed Bean Scope Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseManagedBeanScopeType(ManagedBeanScopeType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Managed Bean Type</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>Managed Bean Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseManagedBeanType(ManagedBeanType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Managed Property Type</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>Managed Property Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseManagedPropertyType(ManagedPropertyType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Map Entries Type</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>Map Entries Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseMapEntriesType(MapEntriesType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Map Entry Type</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>Map Entry Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseMapEntryType(MapEntryType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Message Bundle Type</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>Message Bundle Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseMessageBundleType(MessageBundleType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Name Type</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>Name Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseNameType(NameType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Navigation Case Type</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>Navigation Case Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseNavigationCaseType(NavigationCaseType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Navigation Handler Type</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>Navigation Handler Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseNavigationHandlerType(NavigationHandlerType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Navigation Rule Type</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>Navigation Rule Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseNavigationRuleType(NavigationRuleType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Null Value Type</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>Null Value Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseNullValueType(NullValueType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Ordering Type</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>Ordering Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseOrderingType(OrderingType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Ordering Ordering Type</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>Ordering Ordering Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseOrderingOrderingType(OrderingOrderingType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Ordering Others Type</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>Ordering Others Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseOrderingOthersType(OrderingOthersType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Partial View Context Factory Type</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>Partial View Context Factory Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object casePartialViewContextFactoryType(PartialViewContextFactoryType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Phase Listener Type</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>Phase Listener Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object casePhaseListenerType(PhaseListenerType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Property Class Type</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>Property Class Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object casePropertyClassType(PropertyClassType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Property Extension Type</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>Property Extension Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object casePropertyExtensionType(PropertyExtensionType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Property Name Type</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>Property Name Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object casePropertyNameType(PropertyNameType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Property Resolver Type</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>Property Resolver Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object casePropertyResolverType(PropertyResolverType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Property Type</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>Property Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object casePropertyType(PropertyType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Redirect Type</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>Redirect Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseRedirectType(RedirectType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Redirect View Param Type</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>Redirect View Param Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseRedirectViewParamType(RedirectViewParamType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Referenced Bean Class Type</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>Referenced Bean Class Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseReferencedBeanClassType(ReferencedBeanClassType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Referenced Bean Name Type</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>Referenced Bean Name Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseReferencedBeanNameType(ReferencedBeanNameType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Referenced Bean Type</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>Referenced Bean Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseReferencedBeanType(ReferencedBeanType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Renderer Class Type</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>Renderer Class Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseRendererClassType(RendererClassType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Renderer Extension Type</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>Renderer Extension Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseRendererExtensionType(RendererExtensionType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Renderer Type</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>Renderer Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseRendererType(RendererType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Renderer Type Type</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>Renderer Type Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseRendererTypeType(RendererTypeType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Render Kit Class Type</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>Render Kit Class Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseRenderKitClassType(RenderKitClassType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Render Kit Factory Type</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>Render Kit Factory Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseRenderKitFactoryType(RenderKitFactoryType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Render Kit Id Type</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>Render Kit Id Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseRenderKitIdType(RenderKitIdType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Render Kit Type</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>Render Kit Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseRenderKitType(RenderKitType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Small Icon Type</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>Small Icon Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseSmallIconType(SmallIconType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Source Class Type</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>Source Class Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseSourceClassType(SourceClassType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>State Manager Type</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>State Manager Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseStateManagerType(StateManagerType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Suggested Value Type</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>Suggested Value Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseSuggestedValueType(SuggestedValueType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Supported Locale Type</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>Supported Locale Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseSupportedLocaleType(SupportedLocaleType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>System Event Class Type</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>System Event Class Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseSystemEventClassType(SystemEventClassType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>System Event Listener Class Type</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>System Event Listener Class Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseSystemEventListenerClassType(SystemEventListenerClassType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>System Event Listener Type</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>System Event Listener Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseSystemEventListenerType(SystemEventListenerType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Tag Handler Delegate Factory Type</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>Tag Handler Delegate Factory Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseTagHandlerDelegateFactoryType(TagHandlerDelegateFactoryType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>To View Id Type</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>To View Id Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseToViewIdType(ToViewIdType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Validator Class Type</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>Validator Class Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseValidatorClassType(ValidatorClassType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Validator Id Type</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>Validator Id Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseValidatorIdType(ValidatorIdType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Validator Type</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>Validator Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseValidatorType(ValidatorType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Value Class Type</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>Value Class Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseValueClassType(ValueClassType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Value Type</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>Value Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseValueType(ValueType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Variable Resolver Type</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>Variable Resolver Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseVariableResolverType(VariableResolverType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>View Handler Type</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>View Handler Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseViewHandlerType(ViewHandlerType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Resource Bundle Type</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>Resource Bundle Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-    public Object caseResourceBundleType(ResourceBundleType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Base Name Type</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>Base Name Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-    public Object caseBaseNameType(BaseNameType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Var Type</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>Var Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-    public Object caseVarType(VarType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>View Declaration Language Factory Type</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>View Declaration Language Factory Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseViewDeclarationLanguageFactoryType(ViewDeclarationLanguageFactoryType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Visit Context Factory Type</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>Visit Context Factory Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseVisitContextFactoryType(VisitContextFactoryType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Render Kit Extension Type</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>Render Kit Extension Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-    public Object caseRenderKitExtensionType(RenderKitExtensionType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Resource Handler Type</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>Resource Handler Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseResourceHandlerType(ResourceHandlerType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Navigation Rule Extension Type</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>Navigation Rule Extension Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-    public Object caseNavigationRuleExtensionType(NavigationRuleExtensionType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Validator Extension Type</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>Validator Extension Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-    public Object caseValidatorExtensionType(ValidatorExtensionType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Extension Type</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>Extension Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-    public Object caseFacesConfigExtensionType(FacesConfigExtensionType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Factory Extension Type</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>Factory Extension Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-    public Object caseFactoryExtensionType(FactoryExtensionType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Lifecycle Extension Type</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>Lifecycle Extension Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-    public Object caseLifecycleExtensionType(LifecycleExtensionType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Managed Bean Extension Type</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>Managed Bean Extension Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-    public Object caseManagedBeanExtensionType(ManagedBeanExtensionType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Converter Extension Type</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>Converter Extension Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-    public Object caseConverterExtensionType(ConverterExtensionType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>Extension Type</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>Extension Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-    public Object caseExtensionType(ExtensionType object) {
-		return null;
-	}
-
-    /**
-	 * Returns the result of interpreting the object as an instance of '<em>External Context Factory Type</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>External Context Factory Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public Object caseExternalContextFactoryType(ExternalContextFactoryType object) {
-		return null;
-	}
-
-				/**
-	 * Returns the result of interpreting the object as an instance of '<em>Application Extension Type</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>Application Extension Type</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-    public Object caseApplicationExtensionType(ApplicationExtensionType 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
-	 */
-	public Object defaultCase(EObject object) {
-		return null;
-	}
-
-} //FacesConfigSwitch
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/util/package-info.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/util/package-info.java
deleted file mode 100644
index 629e163..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/emf/util/package-info.java
+++ /dev/null
@@ -1,19 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Oracle - initial API and implementation
- *    
- ********************************************************************************/
-
-/**
- * EMF generated utility classes for JSF application configuration files (deprecated).
- * <p>
- * Deprecated - should be using classes in org.eclipse.jst.jsf.facesconfig.edit.provider.   
- * This package will be removed from the MANIFEST.MF as public API in a future release.
- */
-package org.eclipse.jst.jsf.facesconfig.emf.util;
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/Logger.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/Logger.java
deleted file mode 100644
index ab40d83..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/Logger.java
+++ /dev/null
@@ -1,283 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal;
-
-import java.io.PrintStream;
-import java.util.StringTokenizer;
-
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Platform;
-import org.eclipse.core.runtime.Plugin;
-import org.eclipse.core.runtime.Status;
-import org.eclipse.jst.jsf.facesconfig.FacesConfigPlugin;
-
-
-/**
- * Small convenience class to log messages to plugin's log file and also, if desired,
- * the console. This class should only be used by classes in this plugin. Other
- * plugins should make their own copy, with appropriate ID.
- */
-public class Logger {
-	private static Plugin fPlugin;
-	private static String fPluginId;
-	
-	/**
-	 * Controls whether or not log/trace messages also go to the console.
-	 * Normally, leave this as false.  Change to true temporarily, if desired, for debugging.
-	 */
-	private static boolean displayToConsole = false;
-
-	private static final String TRACEFILTER_LOCATION = "/debug/tracefilter"; //$NON-NLS-1$
-
-	private static final int OK = IStatus.OK; // 0
-	private static final int INFO = IStatus.INFO; // 1
-	private static final int WARNING = IStatus.WARNING; // 2
-	private static final int ERROR = IStatus.ERROR; // 4
-
-	private static final int OK_DEBUG = 200 + OK;
-	private static final int INFO_DEBUG = 200 + INFO;
-	private static final int WARNING_DEBUG = 200 + WARNING;
-	private static final int ERROR_DEBUG = 200 + ERROR;
-
-	/**
-	 * Adds message to log.
-	 * @param level severity level of the message (OK, INFO, WARNING, ERROR, OK_DEBUG, INFO_DEBUG, WARNING_DEBUG, ERROR_DEBUG)
-	 * @param message text to add to the log
-	 * @param exception exception thrown
-	 */
-	protected static void _log(int level, String message, Throwable exception) {
-		if (level == OK_DEBUG || level == INFO_DEBUG || level == WARNING_DEBUG || level == ERROR_DEBUG) {
-			if (!isDebugging())
-				return;
-		}
-
-		int severity = IStatus.OK;
-		switch (level) {
-			case INFO_DEBUG :
-			case INFO :
-				severity = IStatus.INFO;
-				break;
-			case WARNING_DEBUG :
-			case WARNING :
-				severity = IStatus.WARNING;
-				break;
-			case ERROR_DEBUG :
-			case ERROR :
-				severity = IStatus.ERROR;
-		}
-		message = (message != null) ? message : "null"; //$NON-NLS-1$
-		Status statusObj = new Status(severity, getPluginId(), severity, message, exception);
-		getPlugin().getLog().log(statusObj);
-	}
-
-	/**
-	 * Prints message to log if category matches /debug/tracefilter option.
-	 * @param message text to print
-	 * @param category category of the message, to be compared with /debug/tracefilter
-	 * @param exception 
-	 */
-	protected static void _trace(String category, String message, Throwable exception) {
-		if (isTracing(category)) {
-			message = (message != null) ? message : "null"; //$NON-NLS-1$
-			Status statusObj = new Status(IStatus.OK, getPluginId(), IStatus.OK, message, exception);
-			getPlugin().getLog().log(statusObj);
-		}
-	}
-
-	/**
-	 * @return true if the plugin for this logger is debugging
-	 */
-	public static boolean isDebugging() {
-		return getPlugin().isDebugging();
-	}
-
-	/**
-	 * Determines if currently tracing a category
-	 * @param category
-	 * @return true if tracing category, false otherwise
-	 */
-	public static boolean isTracing(String category) {
-		if (!isDebugging())
-			return false;
-
-		String traceFilter = Platform.getDebugOption(getPluginId() + TRACEFILTER_LOCATION);
-		if (traceFilter != null) {
-			StringTokenizer tokenizer = new StringTokenizer(traceFilter, ","); //$NON-NLS-1$
-			while (tokenizer.hasMoreTokens()) {
-				String cat = tokenizer.nextToken().trim();
-				if (category.equals(cat)) {
-					return true;
-				}
-			}
-		}
-		return false;
-	}
-
-	/**
-	 * @param level
-	 * @param message
-	 */
-	public static void log(int level, String message) {
-		_log(level, message, null);
-	}
-
-	/**
-	 * @param level
-	 * @param message
-	 * @param exception
-	 */
-	public static void log(int level, String message, Throwable exception) {
-		_log(level, message, exception);
-	}
-	
-	/**
-	 * @param source
-	 * @param message
-	 */
-	public static void log(Object source, String message) {
-		doLog(source, message, null);
-	}
-
-	/**
-	 * @param source
-	 * @param message
-	 * @param throwable
-	 */
-	public static void log(Object source, String message, Throwable throwable) {
-		doLog(source, message, throwable);
-	}
-
-	/**
-	 * @param source
-	 * @param throwable
-	 */
-	public static void log(Object source, Throwable throwable) {
-		doLog(source, null, throwable);
-	}
-	
-	/**
-	 * @param message
-	 */
-	public static void log(String message) {
-		doLog(message, null);
-	}
-	
-	private static void doLog(String message, Throwable exception) {
-		_log(ERROR, message, exception);
-	}
-	
-	private static void doLog(Object source, String message, Throwable exception) {
-		_log(ERROR, getMessageFor(source, message), exception);
-	}
-	
-	private static final String getMessageFor(Object source, String message) {
-		StringBuffer buffer = new StringBuffer();
-		buffer.append(source);
-		if (message != null) {
-			buffer.append(": "); //$NON-NLS-1$
-			buffer.append(message);
-		}
-		return buffer.toString();
-	}
-
-	/**
-	 * @param message
-	 * @param exception
-	 */
-	public static void logException(String message, Throwable exception) {
-		_log(ERROR, message, exception);
-	}
-
-	/**
-	 * @param exception
-	 */
-	public static void logException(Throwable exception) {
-		_log(ERROR, exception.getMessage(), exception);
-	}
-
-	/**
-	 * @param category
-	 * @param message
-	 * @param exception
-	 */
-	public static void traceException(String category, String message, Throwable exception) {
-		_trace(category, message, exception);
-	}
-
-	/**
-	 * @param category
-	 * @param exception
-	 */
-	public static void traceException(String category, Throwable exception) {
-		_trace(category, exception.getMessage(), exception);
-	}
-
-	/**
-	 * @param category
-	 * @param message
-	 */
-	public static void trace(String category, String message) {
-		_trace(category, message, null);
-	}
-
-	private static Plugin getFacesPlugin() {
-		return FacesConfigPlugin.getPlugin();
-	}
-
-	private static Plugin getPlugin() {
-
-		if (fPlugin == null) {
-			fPlugin = getFacesPlugin();
-		}
-		return fPlugin;
-	}
-
-	/**
-	 * @return the plugin id
-	 */
-	private static String getPluginId() {
-
-		if (fPluginId == null) {
-			fPluginId = ((Plugin) (FacesConfigPlugin.getPlugin())).getBundle().getSymbolicName() ;
-		}
-		return fPluginId;
-	}
-	
-	private static final void doConsole(String message, Throwable throwable) {
-		if (displayToConsole) {
-			PrintStream out = System.out;
-			out.println(message);
-			if (throwable != null)
-				throwable.printStackTrace(out);
-		}
-	}
-	
-	private static final void doTrace(String category, Object source, String message) {
-		message = getMessageFor(source, message);
-		try {
-			_trace(category, message, null);
-		} catch (Exception ignored) {
-			// Empty block intended.
-		} finally {
-			doConsole(message, null);
-		}
-	}
-	
-	/**
-	 * @param category
-	 * @param source
-	 * @param message
-	 */
-	public static void trace(String category, Object source, String message) {
-		doTrace(category, source, message);
-	}
-
-}
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/nls/Messages.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/nls/Messages.java
deleted file mode 100644
index b5897e3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/nls/Messages.java
+++ /dev/null
@@ -1,1408 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.nls;
-
-import org.eclipse.osgi.util.NLS;
-
-/**
- * @author cbateman
- *
- */
-public final class Messages extends NLS {
-
-	private static final String BUNDLE_NAME = "org.eclipse.jst.jsf.facesconfig.internal.nls.messages";//$NON-NLS-1$
-
-	private Messages() {
-		// Do not instantiate
-	}
-
-	/**
-	 * see messages.properties
-	 */
-	public static String Source_UI_;
-	/**
-	 * see messages.properties
-	 */
-	public static String FaceConfigEditor_Title;
-	/**
-	 * see messages.properties
-	 */
-	public static String Overview_Page_Title;
-	/**
-	 * see messages.properties
-	 */
-	public static String Application_Page_Title;
-	/**
-	 * see messages.properties
-	 */
-	public static String Factory_Page_Title;
-	/**
-	 * see messages.properties
-	 */
-	public static String Component_Page_Title;
-	/**
-	 * see messages.properties
-	 */
-	public static String Converter_Page_Title;
-	/**
-	 * see messages.properties
-	 */
-	public static String ManagedBean_Page_Title;
-	/**
-	 * see messages.properties
-	 */
-	public static String NavigationRule_Page_Title;
-	/**
-	 * see messages.properties
-	 */
-	public static String ReferencedBean_Page_Title;
-	/**
-	 * see messages.properties
-	 */
-	public static String RenderKit_Page_Title;
-	/**
-	 * see messages.properties
-	 */
-	public static String Lifecycle_Page_Title;
-	/**
-	 * see messages.properties
-	 */
-	public static String Validator_Page_Title;
-	/**
-	 * see messages.properties
-	 */
-	public static String MANAGEDBEAN_MAIN_SEC_TITLE;
-	/**
-	 * see messages.properties
-	 */
-	public static String MANAGEDBEAN_MAIN_SEC_DESC;
-	/**
-	 * see messages.properties
-	 */
-	public static String Invalid_Config_File;
-	/**
-	 * see messages.properties
-	 */
-	public static String OPEN_TO_FACESCONFIG_SOURCE_PAGE_MENU_LABEL;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_CreateChild_text;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_CreateChild_text2;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_CreateChild_tooltip;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_CreateChild_description;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_CreateSibling_description;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PropertyDescriptor_description;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ActionListenerType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ApplicationFactoryType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ApplicationType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_AttributeExtensionType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_AttributeNameType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_AttributeType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ComponentClassType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ComponentExtensionType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ComponentType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ComponentTypeType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ConverterType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DefaultLocaleType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DescriptionType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DisplayNameType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FacesConfigType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FacesContextFactoryType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FactoryType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_IconType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_LifecycleFactoryType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_LifecycleType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ListEntriesType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_LocaleConfigType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedBeanType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedPropertyType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_MapEntriesType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_MapEntryType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_MessageBundleType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_NavigationCaseType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_NavigationHandlerType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_NavigationRuleType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_NullValueType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PhaseListenerType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PropertyExtensionType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PropertyResolverType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PropertyType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RedirectType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ReferencedBeanType_type;
-	/**
-	 * see messages.properties
-	 */
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RendererExtensionType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RendererType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RenderKitFactoryType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RenderKitType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_StateManagerType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_SupportedComponentClassType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_SupportedComponentTypeType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_SupportedLocaleType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ValidatorType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ValueType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_VariableResolverType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ViewHandlerType_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_Unknown_type;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ActionListenerType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ActionListenerType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ApplicationFactoryType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ApplicationFactoryType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ApplicationType_actionListener_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ApplicationType_messageBundle_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ApplicationType_navigationHandler_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ApplicationType_viewHandler_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ApplicationType_stateManager_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ApplicationType_propertyResolver_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ApplicationType_variableResolver_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ApplicationType_localeConfig_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ApplicationType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_AttributeExtensionType_mixed_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_AttributeExtensionType_group_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_AttributeExtensionType_any_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_AttributeExtensionType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_AttributeNameType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_AttributeNameType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_AttributeType_description_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_AttributeType_displayName_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_AttributeType_icon_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_AttributeType_attributeName_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_AttributeType_attributeExtension_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_AttributeType_attributeClass_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_AttributeType_defaultValue_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_AttributeType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_AttributeType_suggestedValue_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ComponentClassType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ComponentClassType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ComponentExtensionType_mixed_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ComponentExtensionType_group_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ComponentExtensionType_any_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ComponentExtensionType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ComponentType_description_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ComponentType_displayName_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ComponentType_icon_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ComponentType_componentType_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ComponentType_componentClass_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ComponentType_attribute_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ComponentType_property_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ComponentType_componentExtension_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ComponentType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ComponentTypeType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ComponentTypeType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ConverterType_description_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ConverterType_displayName_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ConverterType_icon_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ConverterType_attribute_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ConverterType_property_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ConverterType_converterClass_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ConverterType_converterForClass_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ConverterType_converterId_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ConverterType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DefaultLocaleType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DefaultLocaleType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DescriptionType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DescriptionType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DescriptionType_lang_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DisplayNameType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DisplayNameType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DisplayNameType_lang_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_mixed_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_xMLNSPrefixMap_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_xSISchemaLocation_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_actionListener_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_application_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_applicationFactory_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_attribute_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_attributeExtension_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_attributeName_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_component_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_componentClass_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_componentExtension_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_componentType_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_converter_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_defaultLocale_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_description_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_displayName_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_facesConfig_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_facesContextFactory_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_factory_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_icon_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_lifecycle_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_lifecycleFactory_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_listEntries_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_localeConfig_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_managedBean_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_managedProperty_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_mapEntries_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_mapEntry_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_messageBundle_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_navigationCase_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_navigationHandler_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_navigationRule_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_nullValue_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_phaseListener_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_property_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_propertyExtension_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_propertyResolver_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_redirect_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_referencedBean_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_renderer_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_rendererExtension_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_renderKit_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_renderKitFactory_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_stateManager_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_supportedComponentClass_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_supportedComponentType_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_supportedLocale_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_validator_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_variableResolver_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_DocumentRoot_viewHandler_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FacesConfigType_application_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FacesConfigType_factory_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FacesConfigType_component_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FacesConfigType_converter_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FacesConfigType_managedBean_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FacesConfigType_navigationRule_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FacesConfigType_referencedBean_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FacesConfigType_renderKit_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FacesConfigType_lifecycle_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FacesConfigType_validator_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FacesConfigType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FacesConfigType_xmlns00000_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FacesContextFactoryType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FacesContextFactoryType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FactoryType_applicationFactory_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FactoryType_facesContextFactory_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FactoryType_lifecycleFactory_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FactoryType_renderKitFactory_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_FactoryType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_IconType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_IconType_lang_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_IconType_largeIcon_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_IconType_smallIcon_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_LifecycleFactoryType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_LifecycleFactoryType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_LifecycleType_phaseListener_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_LifecycleType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ListEntriesType_nullValue_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ListEntriesType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ListEntriesType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ListEntriesType_valueClass_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_LocaleConfigType_defaultLocale_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_LocaleConfigType_supportedLocale_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_LocaleConfigType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedBeanType_description_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedBeanType_displayName_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedBeanType_icon_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedBeanType_managedProperty_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedBeanType_mapEntries_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedBeanType_listEntries_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedBeanType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedBeanType_managedBeanClass_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedBeanType_managedBeanName_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedBeanType_managedBeanScope_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedPropertyType_description_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedPropertyType_displayName_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedPropertyType_icon_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedPropertyType_mapEntries_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedPropertyType_listEntries_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedPropertyType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedPropertyType_nullValue_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedPropertyType_propertyClass_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedPropertyType_propertyName_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ManagedPropertyType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_MapEntriesType_mapEntry_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_MapEntriesType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_MapEntriesType_keyClass_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_MapEntriesType_valueClass_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_MapEntryType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_MapEntryType_key_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_MapEntryType_nullValue_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_MapEntryType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_MessageBundleType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_MessageBundleType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_NavigationCaseType_description_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_NavigationCaseType_displayName_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_NavigationCaseType_icon_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_NavigationCaseType_redirect_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_NavigationCaseType_fromAction_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_NavigationCaseType_fromOutcome_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_NavigationCaseType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_NavigationCaseType_toViewId_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_NavigationHandlerType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_NavigationHandlerType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_NavigationRuleType_description_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_NavigationRuleType_displayName_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_NavigationRuleType_icon_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_NavigationRuleType_navigationCase_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_NavigationRuleType_fromViewId_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_NavigationRuleType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_NullValueType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PhaseListenerType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PhaseListenerType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PropertyExtensionType_mixed_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PropertyExtensionType_group_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PropertyExtensionType_any_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PropertyExtensionType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PropertyResolverType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PropertyResolverType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PropertyType_description_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PropertyType_displayName_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PropertyType_icon_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PropertyType_propertyExtension_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PropertyType_defaultValue_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PropertyType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PropertyType_propertyClass_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PropertyType_propertyName_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_PropertyType_suggestedValue_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RedirectType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ReferencedBeanType_description_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ReferencedBeanType_displayName_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ReferencedBeanType_icon_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ReferencedBeanType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ReferencedBeanType_referencedBeanClass_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ReferencedBeanType_referencedBeanName_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RendererExtensionType_mixed_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RendererExtensionType_group_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RendererExtensionType_any_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RendererExtensionType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RendererType_description_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RendererType_displayName_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RendererType_icon_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RendererType_attribute_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RendererType_supportedComponentType_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RendererType_supportedComponentClass_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RendererType_rendererExtension_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RendererType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RendererType_rendererClass_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RendererType_rendererType_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RenderKitFactoryType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RenderKitFactoryType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RenderKitType_description_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RenderKitType_displayName_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RenderKitType_icon_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RenderKitType_renderer_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RenderKitType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RenderKitType_renderKitClass_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_RenderKitType_renderKitId_feature;
-	/**
-	 * see messages.properties
-	 */
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_StateManagerType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_StateManagerType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_SupportedComponentClassType_componentClass_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_SupportedComponentClassType_attributeName_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_SupportedComponentClassType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_SupportedComponentTypeType_componentType_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_SupportedComponentTypeType_attributeName_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_SupportedComponentTypeType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_SupportedLocaleType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_SupportedLocaleType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ValidatorType_description_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ValidatorType_displayName_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ValidatorType_icon_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ValidatorType_attribute_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ValidatorType_property_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ValidatorType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ValidatorType_validatorClass_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ValidatorType_validatorId_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ValueType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ValueType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_VariableResolverType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_VariableResolverType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ViewHandlerType_value_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_ViewHandlerType_id_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String _UI_Unknown_feature;
-	/**
-	 * see messages.properties
-	 */
-	public static String scValidation_duplicate_definition;
-
-	static {
-		NLS.initializeMessages(BUNDLE_NAME, Messages.class);
-	}
-}
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/nls/messages.properties b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/nls/messages.properties
deleted file mode 100644
index 7353707..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/nls/messages.properties
+++ /dev/null
@@ -1,369 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-#/***************************************************************************************************
-# * Copyright (c) 2005, 2006 IBM Corporation and others. 
-# * All rights reserved. This program and the accompanying materials 
-# * are made available under the terms of the Eclipse Public License v1.0
-# * which accompanies this distribution, and is available at
-# * http://www.eclipse.org/legal/epl-v10.html
-# * 
-# * Contributors: 
-# *   IBM Corporation - initial API and implementation
-# **************************************************************************************************/
-Source_UI_ = XML Source
-FaceConfigEditor_Title=Faces Configuration File Editor
-
-Overview_Page_Title=Overview
-Application_Page_Title=Application
-Factory_Page_Title=Factory
-Component_Page_Title=Components
-Converter_Page_Title=Converter
-ManagedBean_Page_Title=Managed Beans
-NavigationRule_Page_Title=Navigation Rules
-ReferencedBean_Page_Title=Referenced Beans
-RenderKit_Page_Title=RenderKits
-Lifecycle_Page_Title=Lifecycle
-Validator_Page_Title=Validator
-
-MANAGEDBEAN_MAIN_SEC_TITLE=Managed Beans
-MANAGEDBEAN_MAIN_SEC_DESC=The following Managed Beans are defined for this config file
-Invalid_Config_File = The Faces Configuration File editor cannot open the file because it is not a valid Faces configuration file.  The XML editor will be opened.
-OPEN_TO_FACESCONFIG_SOURCE_PAGE_MENU_LABEL=Faces Configuration File Editor Source Page
-
-_UI_CreateChild_text = {0}
-_UI_CreateChild_text2 = {1} {0}
-_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_ActionListenerType_type = Action Listener Type
-_UI_ApplicationFactoryType_type = Application Factory Type
-_UI_ApplicationType_type = Application Type
-_UI_AttributeExtensionType_type = Attribute Extension Type
-_UI_AttributeNameType_type = Attribute Name Type
-_UI_AttributeType_type = Attribute Type
-_UI_ComponentClassType_type = Component Class Type
-_UI_ComponentExtensionType_type = Component Extension Type
-_UI_ComponentType_type = Component Type
-_UI_ComponentTypeType_type = Component Type Type
-_UI_ConverterType_type = Converter Type
-_UI_DefaultLocaleType_type = Default Locale Type
-_UI_DescriptionType_type = Description Type
-_UI_DisplayNameType_type = Display Name Type
-_UI_DocumentRoot_type = Document Root
-_UI_FacesConfigType_type = Type
-_UI_FacesContextFactoryType_type = Faces Context Factory Type
-_UI_FactoryType_type = Factory Type
-_UI_IconType_type = Icon Type
-_UI_LifecycleFactoryType_type = Lifecycle Factory Type
-_UI_LifecycleType_type = Lifecycle Type
-_UI_ListEntriesType_type = List Entries Type
-_UI_LocaleConfigType_type = Locale Config Type
-_UI_ManagedBeanType_type = Managed Bean Type
-_UI_ManagedPropertyType_type = Managed Property Type
-_UI_MapEntriesType_type = Map Entries Type
-_UI_MapEntryType_type = Map Entry Type
-_UI_MessageBundleType_type = Message Bundle Type
-_UI_NavigationCaseType_type = Navigation Case Type
-_UI_NavigationHandlerType_type = Navigation Handler Type
-_UI_NavigationRuleType_type = Navigation Rule Type
-_UI_NullValueType_type = Null Value Type
-_UI_PhaseListenerType_type = Phase Listener Type
-_UI_PropertyExtensionType_type = Property Extension Type
-_UI_PropertyResolverType_type = Property Resolver Type
-_UI_PropertyType_type = Property Type
-_UI_RedirectType_type = Redirect Type
-_UI_ReferencedBeanType_type = Referenced Bean Type
-_UI_RendererExtensionType_type = Renderer Extension Type
-_UI_RendererType_type = Renderer Type
-_UI_RenderKitFactoryType_type = Render Kit Factory Type
-_UI_RenderKitType_type = Render Kit Type
-_UI_StateManagerType_type = State Manager Type
-_UI_SupportedComponentClassType_type = Supported Component Class Type
-_UI_SupportedComponentTypeType_type = Supported Component Type Type
-_UI_SupportedLocaleType_type = Supported Locale Type
-_UI_ValidatorType_type = Validator Type
-_UI_ValueType_type = Value Type
-_UI_VariableResolverType_type = Variable Resolver Type
-_UI_ViewHandlerType_type = View Handler Type
-_UI_Unknown_type = Object
-
-_UI_ActionListenerType_value_feature = Value
-_UI_ActionListenerType_id_feature = Id
-_UI_ApplicationFactoryType_value_feature = Value
-_UI_ApplicationFactoryType_id_feature = Id
-_UI_ApplicationType_actionListener_feature = Action Listener
-_UI_ApplicationType_messageBundle_feature = Message Bundle
-_UI_ApplicationType_navigationHandler_feature = Navigation Handler
-_UI_ApplicationType_viewHandler_feature = View Handler
-_UI_ApplicationType_stateManager_feature = State Manager
-_UI_ApplicationType_propertyResolver_feature = Property Resolver
-_UI_ApplicationType_variableResolver_feature = Variable Resolver
-_UI_ApplicationType_localeConfig_feature = Locale Config
-_UI_ApplicationType_id_feature = Id
-_UI_AttributeExtensionType_mixed_feature = Mixed
-_UI_AttributeExtensionType_group_feature = Group
-_UI_AttributeExtensionType_any_feature = Any
-_UI_AttributeExtensionType_id_feature = Id
-_UI_AttributeNameType_value_feature = Value
-_UI_AttributeNameType_id_feature = Id
-_UI_AttributeType_description_feature = Description
-_UI_AttributeType_displayName_feature = Display Name
-_UI_AttributeType_icon_feature = Icon
-_UI_AttributeType_attributeName_feature = Attribute Name
-_UI_AttributeType_attributeExtension_feature = Attribute Extension
-_UI_AttributeType_attributeClass_feature = Attribute Class
-_UI_AttributeType_defaultValue_feature = Default Value
-_UI_AttributeType_id_feature = Id
-_UI_AttributeType_suggestedValue_feature = Suggested Value
-_UI_ComponentClassType_value_feature = Value
-_UI_ComponentClassType_id_feature = Id
-_UI_ComponentExtensionType_mixed_feature = Mixed
-_UI_ComponentExtensionType_group_feature = Group
-_UI_ComponentExtensionType_any_feature = Any
-_UI_ComponentExtensionType_id_feature = Id
-_UI_ComponentType_description_feature = Description
-_UI_ComponentType_displayName_feature = Display Name
-_UI_ComponentType_icon_feature = Icon
-_UI_ComponentType_componentType_feature = Component Type
-_UI_ComponentType_componentClass_feature = Component Class
-_UI_ComponentType_attribute_feature = Attribute
-_UI_ComponentType_property_feature = Property
-_UI_ComponentType_componentExtension_feature = Component Extension
-_UI_ComponentType_id_feature = Id
-_UI_ComponentTypeType_value_feature = Value
-_UI_ComponentTypeType_id_feature = Id
-_UI_ConverterType_description_feature = Description
-_UI_ConverterType_displayName_feature = Display Name
-_UI_ConverterType_icon_feature = Icon
-_UI_ConverterType_attribute_feature = Attribute
-_UI_ConverterType_property_feature = Property
-_UI_ConverterType_converterClass_feature = Converter Class
-_UI_ConverterType_converterForClass_feature = Converter For Class
-_UI_ConverterType_converterId_feature = Converter Id
-_UI_ConverterType_id_feature = Id
-_UI_DefaultLocaleType_value_feature = Value
-_UI_DefaultLocaleType_id_feature = Id
-_UI_DescriptionType_value_feature = Value
-_UI_DescriptionType_id_feature = Id
-_UI_DescriptionType_lang_feature = Lang
-_UI_DisplayNameType_value_feature = Value
-_UI_DisplayNameType_id_feature = Id
-_UI_DisplayNameType_lang_feature = Lang
-_UI_DocumentRoot_mixed_feature = Mixed
-_UI_DocumentRoot_xMLNSPrefixMap_feature = XMLNS Prefix Map
-_UI_DocumentRoot_xSISchemaLocation_feature = XSI Schema Location
-_UI_DocumentRoot_actionListener_feature = Action Listener
-_UI_DocumentRoot_application_feature = Application
-_UI_DocumentRoot_applicationFactory_feature = Application Factory
-_UI_DocumentRoot_attribute_feature = Attribute
-_UI_DocumentRoot_attributeExtension_feature = Attribute Extension
-_UI_DocumentRoot_attributeName_feature = Attribute Name
-_UI_DocumentRoot_component_feature = Component
-_UI_DocumentRoot_componentClass_feature = Component Class
-_UI_DocumentRoot_componentExtension_feature = Component Extension
-_UI_DocumentRoot_componentType_feature = Component Type
-_UI_DocumentRoot_converter_feature = Converter
-_UI_DocumentRoot_defaultLocale_feature = Default Locale
-_UI_DocumentRoot_description_feature = Description
-_UI_DocumentRoot_displayName_feature = Display Name
-_UI_DocumentRoot_facesConfig_feature = Faces Config
-_UI_DocumentRoot_facesContextFactory_feature = Faces Context Factory
-_UI_DocumentRoot_factory_feature = Factory
-_UI_DocumentRoot_icon_feature = Icon
-_UI_DocumentRoot_lifecycle_feature = Lifecycle
-_UI_DocumentRoot_lifecycleFactory_feature = Lifecycle Factory
-_UI_DocumentRoot_listEntries_feature = List Entries
-_UI_DocumentRoot_localeConfig_feature = Locale Config
-_UI_DocumentRoot_managedBean_feature = Managed Bean
-_UI_DocumentRoot_managedProperty_feature = Managed Property
-_UI_DocumentRoot_mapEntries_feature = Map Entries
-_UI_DocumentRoot_mapEntry_feature = Map Entry
-_UI_DocumentRoot_messageBundle_feature = Message Bundle
-_UI_DocumentRoot_navigationCase_feature = Navigation Case
-_UI_DocumentRoot_navigationHandler_feature = Navigation Handler
-_UI_DocumentRoot_navigationRule_feature = Navigation Rule
-_UI_DocumentRoot_nullValue_feature = Null Value
-_UI_DocumentRoot_phaseListener_feature = Phase Listener
-_UI_DocumentRoot_property_feature = Property
-_UI_DocumentRoot_propertyExtension_feature = Property Extension
-_UI_DocumentRoot_propertyResolver_feature = Property Resolver
-_UI_DocumentRoot_redirect_feature = Redirect
-_UI_DocumentRoot_referencedBean_feature = Referenced Bean
-_UI_DocumentRoot_renderer_feature = Renderer
-_UI_DocumentRoot_rendererExtension_feature = Renderer Extension
-_UI_DocumentRoot_renderKit_feature = Render Kit
-_UI_DocumentRoot_renderKitFactory_feature = Render Kit Factory
-_UI_DocumentRoot_stateManager_feature = State Manager
-_UI_DocumentRoot_supportedComponentClass_feature = Supported Component Class
-_UI_DocumentRoot_supportedComponentType_feature = Supported Component Type
-_UI_DocumentRoot_supportedLocale_feature = Supported Locale
-_UI_DocumentRoot_validator_feature = Validator
-_UI_DocumentRoot_value_feature = Value
-_UI_DocumentRoot_variableResolver_feature = Variable Resolver
-_UI_DocumentRoot_viewHandler_feature = View Handler
-_UI_FacesConfigType_application_feature = Application
-_UI_FacesConfigType_factory_feature = Factory
-_UI_FacesConfigType_component_feature = Component
-_UI_FacesConfigType_converter_feature = Converter
-_UI_FacesConfigType_managedBean_feature = Managed Bean
-_UI_FacesConfigType_navigationRule_feature = Navigation Rule
-_UI_FacesConfigType_referencedBean_feature = Referenced Bean
-_UI_FacesConfigType_renderKit_feature = Render Kit
-_UI_FacesConfigType_lifecycle_feature = Lifecycle
-_UI_FacesConfigType_validator_feature = Validator
-_UI_FacesConfigType_id_feature = Id
-_UI_FacesConfigType_xmlns00000_feature = Xmlns00000
-_UI_FacesContextFactoryType_value_feature = Value
-_UI_FacesContextFactoryType_id_feature = Id
-_UI_FactoryType_applicationFactory_feature = Application Factory
-_UI_FactoryType_facesContextFactory_feature = Faces Context Factory
-_UI_FactoryType_lifecycleFactory_feature = Lifecycle Factory
-_UI_FactoryType_renderKitFactory_feature = Render Kit Factory
-_UI_FactoryType_id_feature = Id
-_UI_IconType_id_feature = Id
-_UI_IconType_lang_feature = Lang
-_UI_IconType_largeIcon_feature = Large Icon
-_UI_IconType_smallIcon_feature = Small Icon
-_UI_LifecycleFactoryType_value_feature = Value
-_UI_LifecycleFactoryType_id_feature = Id
-_UI_LifecycleType_phaseListener_feature = Phase Listener
-_UI_LifecycleType_id_feature = Id
-_UI_ListEntriesType_nullValue_feature = Null Value
-_UI_ListEntriesType_value_feature = Value
-_UI_ListEntriesType_id_feature = Id
-_UI_ListEntriesType_valueClass_feature = Value Class
-_UI_LocaleConfigType_defaultLocale_feature = Default Locale
-_UI_LocaleConfigType_supportedLocale_feature = Supported Locale
-_UI_LocaleConfigType_id_feature = Id
-_UI_ManagedBeanType_description_feature = Description
-_UI_ManagedBeanType_displayName_feature = Display Name
-_UI_ManagedBeanType_icon_feature = Icon
-_UI_ManagedBeanType_managedProperty_feature = Managed Property
-_UI_ManagedBeanType_mapEntries_feature = Map Entries
-_UI_ManagedBeanType_listEntries_feature = List Entries
-_UI_ManagedBeanType_id_feature = Id
-_UI_ManagedBeanType_managedBeanClass_feature = Managed Bean Class
-_UI_ManagedBeanType_managedBeanName_feature = Managed Bean Name
-_UI_ManagedBeanType_managedBeanScope_feature = Managed Bean Scope
-_UI_ManagedPropertyType_description_feature = Description
-_UI_ManagedPropertyType_displayName_feature = Display Name
-_UI_ManagedPropertyType_icon_feature = Icon
-_UI_ManagedPropertyType_mapEntries_feature = Map Entries
-_UI_ManagedPropertyType_listEntries_feature = List Entries
-_UI_ManagedPropertyType_id_feature = Id
-_UI_ManagedPropertyType_nullValue_feature = Null Value
-_UI_ManagedPropertyType_propertyClass_feature = Property Class
-_UI_ManagedPropertyType_propertyName_feature = Property Name
-_UI_ManagedPropertyType_value_feature = Value
-_UI_MapEntriesType_mapEntry_feature = Map Entry
-_UI_MapEntriesType_id_feature = Id
-_UI_MapEntriesType_keyClass_feature = Key Class
-_UI_MapEntriesType_valueClass_feature = Value Class
-_UI_MapEntryType_id_feature = Id
-_UI_MapEntryType_key_feature = Key
-_UI_MapEntryType_nullValue_feature = Null Value
-_UI_MapEntryType_value_feature = Value
-_UI_MessageBundleType_value_feature = Value
-_UI_MessageBundleType_id_feature = Id
-_UI_NavigationCaseType_description_feature = Description
-_UI_NavigationCaseType_displayName_feature = Display Name
-_UI_NavigationCaseType_icon_feature = Icon
-_UI_NavigationCaseType_redirect_feature = Redirect
-_UI_NavigationCaseType_fromAction_feature = From Action
-_UI_NavigationCaseType_fromOutcome_feature = From Outcome
-_UI_NavigationCaseType_id_feature = Id
-_UI_NavigationCaseType_toViewId_feature = To View Id
-_UI_NavigationHandlerType_value_feature = Value
-_UI_NavigationHandlerType_id_feature = Id
-_UI_NavigationRuleType_description_feature = Description
-_UI_NavigationRuleType_displayName_feature = Display Name
-_UI_NavigationRuleType_icon_feature = Icon
-_UI_NavigationRuleType_navigationCase_feature = Navigation Case
-_UI_NavigationRuleType_fromViewId_feature = From View Id
-_UI_NavigationRuleType_id_feature = Id
-_UI_NullValueType_id_feature = Id
-_UI_PhaseListenerType_value_feature = Value
-_UI_PhaseListenerType_id_feature = Id
-_UI_PropertyExtensionType_mixed_feature = Mixed
-_UI_PropertyExtensionType_group_feature = Group
-_UI_PropertyExtensionType_any_feature = Any
-_UI_PropertyExtensionType_id_feature = Id
-_UI_PropertyResolverType_value_feature = Value
-_UI_PropertyResolverType_id_feature = Id
-_UI_PropertyType_description_feature = Description
-_UI_PropertyType_displayName_feature = Display Name
-_UI_PropertyType_icon_feature = Icon
-_UI_PropertyType_propertyExtension_feature = Property Extension
-_UI_PropertyType_defaultValue_feature = Default Value
-_UI_PropertyType_id_feature = Id
-_UI_PropertyType_propertyClass_feature = Property Class
-_UI_PropertyType_propertyName_feature = Property Name
-_UI_PropertyType_suggestedValue_feature = Suggested Value
-_UI_RedirectType_id_feature = Id
-_UI_ReferencedBeanType_description_feature = Description
-_UI_ReferencedBeanType_displayName_feature = Display Name
-_UI_ReferencedBeanType_icon_feature = Icon
-_UI_ReferencedBeanType_id_feature = Id
-_UI_ReferencedBeanType_referencedBeanClass_feature = Referenced Bean Class
-_UI_ReferencedBeanType_referencedBeanName_feature = Referenced Bean Name
-_UI_RendererExtensionType_mixed_feature = Mixed
-_UI_RendererExtensionType_group_feature = Group
-_UI_RendererExtensionType_any_feature = Any
-_UI_RendererExtensionType_id_feature = Id
-_UI_RendererType_description_feature = Description
-_UI_RendererType_displayName_feature = Display Name
-_UI_RendererType_icon_feature = Icon
-_UI_RendererType_attribute_feature = Attribute
-_UI_RendererType_supportedComponentType_feature = Supported Component Type
-_UI_RendererType_supportedComponentClass_feature = Supported Component Class
-_UI_RendererType_rendererExtension_feature = Renderer Extension
-_UI_RendererType_id_feature = Id
-_UI_RendererType_rendererClass_feature = Renderer Class
-_UI_RendererType_rendererType_feature = Renderer Type
-_UI_RenderKitFactoryType_value_feature = Value
-_UI_RenderKitFactoryType_id_feature = Id
-_UI_RenderKitType_description_feature = Description
-_UI_RenderKitType_displayName_feature = Display Name
-_UI_RenderKitType_icon_feature = Icon
-_UI_RenderKitType_renderer_feature = Renderer
-_UI_RenderKitType_id_feature = Id
-_UI_RenderKitType_renderKitClass_feature = Render Kit Class
-_UI_RenderKitType_renderKitId_feature = Render Kit Id
-_UI_StateManagerType_value_feature = Value
-_UI_StateManagerType_id_feature = Id
-_UI_SupportedComponentClassType_componentClass_feature = Component Class
-_UI_SupportedComponentClassType_attributeName_feature = Attribute Name
-_UI_SupportedComponentClassType_id_feature = Id
-_UI_SupportedComponentTypeType_componentType_feature = Component Type
-_UI_SupportedComponentTypeType_attributeName_feature = Attribute Name
-_UI_SupportedComponentTypeType_id_feature = Id
-_UI_SupportedLocaleType_value_feature = Value
-_UI_SupportedLocaleType_id_feature = Id
-_UI_ValidatorType_description_feature = Description
-_UI_ValidatorType_displayName_feature = Display Name
-_UI_ValidatorType_icon_feature = Icon
-_UI_ValidatorType_attribute_feature = Attribute
-_UI_ValidatorType_property_feature = Property
-_UI_ValidatorType_id_feature = Id
-_UI_ValidatorType_validatorClass_feature = Validator Class
-_UI_ValidatorType_validatorId_feature = Validator Id
-_UI_ValueType_value_feature = Value
-_UI_ValueType_id_feature = Id
-_UI_VariableResolverType_value_feature = Value
-_UI_VariableResolverType_id_feature = Id
-_UI_ViewHandlerType_value_feature = Value
-_UI_ViewHandlerType_id_feature = Id
-_UI_Unknown_feature = Unspecified
-
-scValidation_duplicate_definition=Duplicate {0} {1}
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/AbsoluteOrderingTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/AbsoluteOrderingTranslator.java
deleted file mode 100644
index 9b0475f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/AbsoluteOrderingTranslator.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang, itrimble
- *
- */
-public class AbsoluteOrderingTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public AbsoluteOrderingTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-				new NameTranslator("name", facesPackage.getAbsoluteOrderingType_Name()), //$NON-NLS-1$
-				new OrderingOthersTranslator("others", facesPackage.getAbsoluteOrderingType_Others()) //$NON-NLS-1$
-//				new Translator("id", facesPackage.getAbsoluteOrderingType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ActionListenerTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ActionListenerTranslator.java
deleted file mode 100644
index a1e0617..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ActionListenerTranslator.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class ActionListenerTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ActionListenerTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/*  (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getActionListenerType_TextContent()),
-			new Translator("id", facesPackage.getActionListenerType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ApplicationExtensionTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ApplicationExtensionTranslator.java
deleted file mode 100644
index 5fa3beb..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ApplicationExtensionTranslator.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-/**
- * Transtor for application extensions
- * 
- * @author cbateman
- *
- */
-public class ApplicationExtensionTranslator extends ExtensionTypeTranslator {
-
-    /**
-     * @param domNameAndPath
-     * @param feature
-     */
-    public ApplicationExtensionTranslator(String domNameAndPath,
-            EStructuralFeature feature) {
-        super(domNameAndPath, feature);
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ApplicationFactoryTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ApplicationFactoryTranslator.java
deleted file mode 100644
index 333ac00..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ApplicationFactoryTranslator.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class ApplicationFactoryTranslator extends Translator {
-	/**
-	 * @param domNameAndPath 
-	 * @param aFeature 
-	 */
-	public ApplicationFactoryTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getApplicationFactoryType_TextContent()),
-			new Translator("id", facesPackage.getApplicationFactoryType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ApplicationTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ApplicationTranslator.java
deleted file mode 100644
index 5a396ac..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ApplicationTranslator.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang, itrimble
- *
- */
-public class ApplicationTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ApplicationTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-				new ActionListenerTranslator("action-listener", facesPackage.getApplicationType_ActionListener()), //$NON-NLS-1$
-				new DefaultRenderKitIdTranslator("default-render-kit-id", facesPackage.getApplicationType_DefaultRenderKitId()), //$NON-NLS-1$
-				new MessageBundleTranslator("message-bundle", facesPackage.getApplicationType_MessageBundle()), //$NON-NLS-1$
-				new NavigationHandlerTranslator("navigation-handler", facesPackage.getApplicationType_NavigationHandler()), //$NON-NLS-1$
-//				new PartialTraversalTranslator("partial-traversal", facesPackage.getApplicationType_PartialTraversal()), //$NON-NLS-1$
-				new ViewHandlerTranslator("view-handler", facesPackage.getApplicationType_ViewHandler()), //$NON-NLS-1$
-				new StateManagerTranslator("state-manager", facesPackage.getApplicationType_StateManager()), //$NON-NLS-1$
-                new ELResolverTypeTranslator("el-resolver", facesPackage.getApplicationType_ELResolver()), //$NON-NLS-1$
-				new PropertyResolverTranslator("property-resolver", facesPackage.getApplicationType_PropertyResolver()), //$NON-NLS-1$
-				new VariableResolverTranslator("variable-resolver", facesPackage.getApplicationType_VariableResolver()), //$NON-NLS-1$
-				new ResourceHandlerTranslator("resource-handler", facesPackage.getApplicationType_ResourceHandler()), //$NON-NLS-1$
-				new SystemEventListenerTranslator("system-event-listener", facesPackage.getApplicationType_SystemEventListener()), //$NON-NLS-1$
-				new LocaleConfigTranslator("locale-config", facesPackage.getApplicationType_LocaleConfig()), //$NON-NLS-1$
-                new ResourceBundleTranslator("resource-bundle", facesPackage.getApplicationType_ResourceBundle()), //$NON-NLS-1$
-                new ApplicationExtensionTranslator("application-extension", facesPackage.getApplicationType_ApplicationExtension()), //$NON-NLS-1$
-				new DefaultValidatorsTranslator("default-validators", facesPackage.getApplicationType_DefaultValidators()), //$NON-NLS-1$
-				new Translator("id", facesPackage.getApplicationType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/AttributeClassTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/AttributeClassTranslator.java
deleted file mode 100644
index fd9ca23..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/AttributeClassTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for attributes
- *
- */
-public class AttributeClassTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public AttributeClassTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getAttributeClassType_TextContent()),
-			new Translator("id", facesPackage.getAttributeClassType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/AttributeExtensionTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/AttributeExtensionTranslator.java
deleted file mode 100644
index cc99005..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/AttributeExtensionTranslator.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-/**
- * @author xnjiang, itrimble
- *
- */
-public class AttributeExtensionTranslator extends ExtensionTypeTranslator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public AttributeExtensionTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/AttributeNameTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/AttributeNameTranslator.java
deleted file mode 100644
index 71ee9f1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/AttributeNameTranslator.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for attribute names
- * 
- * @author cbateman
- *
- */
-public class AttributeNameTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public AttributeNameTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getAttributeNameType_TextContent()),
-			new Translator("id", facesPackage.getAttributeNameType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/AttributeTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/AttributeTranslator.java
deleted file mode 100644
index 3916ed1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/AttributeTranslator.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - fixed getChildren()
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class AttributeTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public AttributeTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new DescriptionTranslator("description", facesPackage.getAttributeType_Description()), //$NON-NLS-1$
-			new DisplayNameTranslator("display-name", facesPackage.getAttributeType_DisplayName()), //$NON-NLS-1$
-			new IconTranslator("icon", facesPackage.getAttributeType_Icon()), //$NON-NLS-1$
-			new AttributeNameTranslator("attribute-name", facesPackage.getAttributeType_AttributeName()), //$NON-NLS-1$
-			new AttributeClassTranslator("attribute-class", facesPackage.getAttributeType_AttributeClass()), //$NON-NLS-1$
-			new DefaultValueTranslator("default-value", facesPackage.getAttributeType_DefaultValue()), //$NON-NLS-1$
-			new SuggestedValueTranslator("suggested-value", facesPackage.getAttributeType_SuggestedValue()), //$NON-NLS-1$
-			new AttributeExtensionTranslator("attribute-extension", facesPackage.getAttributeType_AttributeExtension()), //$NON-NLS-1$
-			new Translator("id", facesPackage.getAttributeType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/BaseNameTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/BaseNameTranslator.java
deleted file mode 100644
index b5296cf..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/BaseNameTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for the base name on a message bundle
- * 
- * @author cbateman
- *
- */
-public class BaseNameTranslator extends Translator {
-
-    /**
-     * @param domNameAndPath
-     * @param feature
-     */
-    public BaseNameTranslator(String domNameAndPath, EStructuralFeature feature) {
-        super(domNameAndPath, feature, END_TAG_NO_INDENT);
-    }
-
-    public Translator[] getChildren()
-    {
-        FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-
-        return new Translator[] {
-            new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getBaseNameType_TextContent()),
-            new Translator("id", facesPackage.getBaseNameType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-        };
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/BehaviorClassTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/BehaviorClassTranslator.java
deleted file mode 100644
index 90bb48c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/BehaviorClassTranslator.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class BehaviorClassTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public BehaviorClassTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/*  (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getBehaviorClassType_TextContent()),
-			new Translator("id", facesPackage.getBehaviorClassType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/BehaviorExtensionTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/BehaviorExtensionTranslator.java
deleted file mode 100644
index a7d452f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/BehaviorExtensionTranslator.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-/**
- * Transtor for application extensions
- * 
- * @author cbateman
- *
- */
-public class BehaviorExtensionTranslator extends ExtensionTypeTranslator {
-
-    /**
-     * @param domNameAndPath
-     * @param feature
-     */
-    public BehaviorExtensionTranslator(String domNameAndPath,
-            EStructuralFeature feature) {
-        super(domNameAndPath, feature);
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/BehaviorIdTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/BehaviorIdTranslator.java
deleted file mode 100644
index 8d45df5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/BehaviorIdTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for the validator id
- *
- */
-public class BehaviorIdTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public BehaviorIdTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getBehaviorIdType_TextContent()),
-			new Translator("id", facesPackage.getBehaviorIdType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/BehaviorTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/BehaviorTranslator.java
deleted file mode 100644
index c72342d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/BehaviorTranslator.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang, itrimble
- *
- */
-public class BehaviorTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public BehaviorTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-				new DescriptionTranslator("description", facesPackage.getBehaviorType_Description()), //$NON-NLS-1$
-				new DisplayNameTranslator("display-name", facesPackage.getBehaviorType_DisplayName()), //$NON-NLS-1$
-				new IconTranslator("icon", facesPackage.getBehaviorType_Icon()), //$NON-NLS-1$
-                new BehaviorIdTranslator("behavior-id", facesPackage.getBehaviorType_BehaviorId()), //$NON-NLS-1$
-                new BehaviorClassTranslator("behavior-class", facesPackage.getBehaviorType_BehaviorClass()), //$NON-NLS-1$
-                new AttributeTranslator("attribute", facesPackage.getBehaviorType_Attribute()), //$NON-NLS-1$
-                new PropertyTranslator("property", facesPackage.getBehaviorType_Property()), //$NON-NLS-1$
-                new BehaviorExtensionTranslator("behavior-extension", facesPackage.getBehaviorType_BehaviorExtension()) //$NON-NLS-1$
-				//new Translator("id", facesPackage.getBehaviorType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ClientBehaviorRendererClassTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ClientBehaviorRendererClassTranslator.java
deleted file mode 100644
index 2c64b67..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ClientBehaviorRendererClassTranslator.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class ClientBehaviorRendererClassTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ClientBehaviorRendererClassTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/*  (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getClientBehaviorRendererClassType_TextContent()),
-			new Translator("id", facesPackage.getClientBehaviorRendererClassType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ClientBehaviorRendererTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ClientBehaviorRendererTranslator.java
deleted file mode 100644
index ac3279c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ClientBehaviorRendererTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class ClientBehaviorRendererTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ClientBehaviorRendererTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/*  (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-            new ClientBehaviorRendererTypeTranslator("client-behavior-renderer-type", facesPackage.getClientBehaviorRendererType_ClientBehaviorRendererType()), //$NON-NLS-1$
-            new ClientBehaviorRendererClassTranslator("client-behavior-renderer-class", facesPackage.getClientBehaviorRendererType_ClientBehaviorRendererClass()) //$NON-NLS-1$
-			//new Translator("id", facesPackage.getClientBehaviorRendererType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ClientBehaviorRendererTypeTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ClientBehaviorRendererTypeTranslator.java
deleted file mode 100644
index 2ddd9ea..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ClientBehaviorRendererTypeTranslator.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class ClientBehaviorRendererTypeTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ClientBehaviorRendererTypeTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/*  (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getClientBehaviorRendererTypeType_TextContent()),
-			new Translator("id", facesPackage.getClientBehaviorRendererTypeType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ComponentClassTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ComponentClassTranslator.java
deleted file mode 100644
index 1a10fd7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ComponentClassTranslator.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Component class translator
- * 
- * @author cbateman
- *
- */
-public class ComponentClassTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ComponentClassTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getComponentClassType_TextContent()),
-			new Translator("id", facesPackage.getComponentClassType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ComponentExtensionTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ComponentExtensionTranslator.java
deleted file mode 100644
index 759aa58..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ComponentExtensionTranslator.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - fixed getChildren()
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-/**
- * @author xnjiang, itrimble
- *
- */
-public class ComponentExtensionTranslator extends ExtensionTypeTranslator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ComponentExtensionTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ComponentFamilyTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ComponentFamilyTranslator.java
deleted file mode 100644
index ac615d2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ComponentFamilyTranslator.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for the component family property
- * @author cbateman
- *
- */
-public class ComponentFamilyTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ComponentFamilyTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getComponentFamilyType_TextContent()),
-			new Translator("id", facesPackage.getComponentFamilyType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ComponentTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ComponentTranslator.java
deleted file mode 100644
index 437f644..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ComponentTranslator.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - fixed getChildren()
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class ComponentTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ComponentTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new DescriptionTranslator("description", facesPackage.getComponentType_Description()), //$NON-NLS-1$
-			new DisplayNameTranslator("display-name", facesPackage.getComponentType_DisplayName()), //$NON-NLS-1$
-			new IconTranslator("icon", facesPackage.getComponentType_Icon()), //$NON-NLS-1$
-			new ComponentTypeTranslator("component-type", facesPackage.getComponentType_ComponentType()), //$NON-NLS-1$
-			new ComponentClassTranslator("component-class", facesPackage.getComponentType_ComponentClass()), //$NON-NLS-1$
-			new FacetTranslator("facet", facesPackage.getComponentType_Facet()), //$NON-NLS-1$
-			new AttributeTranslator("attribute", facesPackage.getComponentType_Attribute()), //$NON-NLS-1$
-			new PropertyTranslator("property", facesPackage.getComponentType_Property()), //$NON-NLS-1$
-			new ComponentExtensionTranslator("component-extension", facesPackage.getComponentType_ComponentExtension()),//ComponentExtensionTranslator("component-extension", facesPackage.getComponentType_ComponentExtension()), //$NON-NLS-1$
-			new Translator("id", facesPackage.getComponentType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ComponentTypeTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ComponentTypeTranslator.java
deleted file mode 100644
index e489cbf..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ComponentTypeTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translater of components
- *
- */
-public class ComponentTypeTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ComponentTypeTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getComponentTypeType_TextContent()),
-			new Translator("id", facesPackage.getComponentTypeType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ConverterClassTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ConverterClassTranslator.java
deleted file mode 100644
index c1f6221..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ConverterClassTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for converters
- *
- */
-public class ConverterClassTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ConverterClassTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getConverterClassType_TextContent()),
-			new Translator("id", facesPackage.getConverterClassType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ConverterExtensionTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ConverterExtensionTranslator.java
deleted file mode 100644
index 66f8292..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ConverterExtensionTranslator.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-/**
- * Translator for extension data on converters
- * 
- * @author cbateman
- *
- */
-public class ConverterExtensionTranslator extends ExtensionTypeTranslator 
-{
-    /**
-     * @param domNameAndPath
-     * @param feature
-     */
-    public ConverterExtensionTranslator(String domNameAndPath,
-            EStructuralFeature feature) 
-    {
-        super(domNameAndPath, feature);
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ConverterForClassTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ConverterForClassTranslator.java
deleted file mode 100644
index 31f603c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ConverterForClassTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * ConverterForClass translator
- *
- */
-public class ConverterForClassTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ConverterForClassTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getConverterForClassType_TextContent()),
-			new Translator("id", facesPackage.getConverterForClassType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ConverterIdTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ConverterIdTranslator.java
deleted file mode 100644
index b0a8a19..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ConverterIdTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for converter id
- *
- */
-public class ConverterIdTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ConverterIdTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getConverterIdType_TextContent()),
-			new Translator("id", facesPackage.getConverterIdType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ConverterTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ConverterTranslator.java
deleted file mode 100644
index 11a0c68..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ConverterTranslator.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - fixed getChildren()
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class ConverterTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ConverterTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new DescriptionTranslator("description", facesPackage.getConverterType_Description()), //$NON-NLS-1$
-			new DisplayNameTranslator("display-name", facesPackage.getConverterType_DisplayName()), //$NON-NLS-1$
-			new IconTranslator("icon", facesPackage.getConverterType_Icon()), //$NON-NLS-1$
-			new ConverterIdTranslator("converter-id", facesPackage.getConverterType_ConverterId()), //$NON-NLS-1$
-			new ConverterForClassTranslator("converter-for-class", facesPackage.getConverterType_ConverterForClass()), //$NON-NLS-1$
-			new ConverterClassTranslator("converter-class", facesPackage.getConverterType_ConverterClass()), //$NON-NLS-1$
-			new AttributeTranslator("attribute", facesPackage.getConverterType_Attribute()), //$NON-NLS-1$
-			new PropertyTranslator("property", facesPackage.getConverterType_Property()), //$NON-NLS-1$
-            new ConverterExtensionTranslator("converter-extension", facesPackage.getConverterType_ConverterExtension()), //$NON-NLS-1$
-			new Translator("id", facesPackage.getConverterType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/DefaultLocaleTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/DefaultLocaleTranslator.java
deleted file mode 100644
index bf74445..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/DefaultLocaleTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for default locale
- *
- */
-public class DefaultLocaleTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public DefaultLocaleTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getDefaultLocaleType_TextContent()),
-			new Translator("id", facesPackage.getDefaultLocaleType_Id(), DOM_ATTRIBUTE)//$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/DefaultRenderKitIdTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/DefaultRenderKitIdTranslator.java
deleted file mode 100644
index bbd9307..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/DefaultRenderKitIdTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang, itrimble
- *
- */
-public class DefaultRenderKitIdTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public DefaultRenderKitIdTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getDefaultRenderKitIdType_TextContent()),
-			new Translator("id", facesPackage.getDefaultRenderKitIdType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/DefaultValidatorsTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/DefaultValidatorsTranslator.java
deleted file mode 100644
index de93d93..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/DefaultValidatorsTranslator.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class DefaultValidatorsTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public DefaultValidatorsTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/*  (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new ValidatorIdTranslator("validator-id", facesPackage.getDefaultValidatorsType_ValidatorId()), //$NON-NLS-1$
-			new Translator("id", facesPackage.getDefaultValidatorsType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/DefaultValueTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/DefaultValueTranslator.java
deleted file mode 100644
index cb23479..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/DefaultValueTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for default values
- *
- */
-public class DefaultValueTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public DefaultValueTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getDefaultValueType_TextContent()),
-			new Translator("id", facesPackage.getDefaultValueType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/DescriptionTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/DescriptionTranslator.java
deleted file mode 100644
index d6faf0d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/DescriptionTranslator.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added text content and id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class DescriptionTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public DescriptionTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getDescriptionType_TextContent()),
-			new Translator("xml:lang", facesPackage.getDescriptionType_Lang(), DOM_ATTRIBUTE), //$NON-NLS-1$
-			new Translator("id", facesPackage.getDescriptionType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/DisplayNameTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/DisplayNameTranslator.java
deleted file mode 100644
index e48a3c7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/DisplayNameTranslator.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added text content and id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class DisplayNameTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public DisplayNameTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getDisplayNameType_TextContent()),
-			new Translator("xml:lang", facesPackage.getDisplayNameType_Lang(), DOM_ATTRIBUTE), //$NON-NLS-1$
-			new Translator("id", facesPackage.getDisplayNameType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/DynamicElementTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/DynamicElementTranslator.java
deleted file mode 100644
index d6173a7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/DynamicElementTranslator.java
+++ /dev/null
@@ -1,496 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-/**
- * 
- */
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-
-import org.eclipse.emf.common.notify.Notifier;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.jst.jsf.facesconfig.emf.DynamicAttribute;
-import org.eclipse.jst.jsf.facesconfig.emf.DynamicElement;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigFactory;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.ReadAheadHelper;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-import org.eclipse.wst.common.internal.emf.resource.TranslatorPath;
-import org.eclipse.wst.common.internal.emf.resource.VariableTranslatorFactory;
-import org.w3c.dom.Attr;
-import org.w3c.dom.NamedNodeMap;
-import org.w3c.dom.Node;
-
-class DynamicElementTranslator extends Translator implements IAnyTranslator
-{
-    public boolean isManagedByParent() {
-        return false;
-    }
-
-    protected Translator[] getChildren() 
-    {
-        FacesConfigPackage facesConfigPackage = FacesConfigPackage.eINSTANCE;
-
-        return new Translator[]
-        {
-            new DynamicElementTranslator("*", facesConfigPackage.getDynamicElement_ChildNodes()), //$NON-NLS-1$
-            new Translator(TEXT_ATTRIBUTE_VALUE, facesConfigPackage.getDynamicElement_TextContent())
-            {
-                public Object getMOFValue(EObject object)
-                {
-                    // TODO: this is a bit of a hack.  The problem is
-                    // that for some reason, if this translator returns
-                    // null, then EMF2DOMAdapterImpl.updateDOMSubtree will
-                    // remove the containing DynamicElement node completely.
-                    // Returning an non-null empty value seems to work
-                    // around this for now.
-                    Object value = super.getMOFValue(object);
-                    return value != null ? value : ""; //$NON-NLS-1$
-                }
-            }
-        };
-    }
-
-    /**
-     * @param domNameAndPath
-     * @param feature
-     */
-    public DynamicElementTranslator(String domNameAndPath,
-            EStructuralFeature feature) 
-    {
-        super(domNameAndPath, feature);
-    }
-    public boolean isMapFor(String domName) {
-        return true;
-    }
-    
-    public EObject createEMFObject(String nodeName, String readAheadName) {
-        // tag name is based on the name property
-        DynamicElement element = FacesConfigFactory.eINSTANCE.createDynamicElement();
-        element.setName(nodeName);
-        return element;
-    }
-
-    public String getDOMName(Object value) {
-        // tag name is based on the name property
-        if (value instanceof DynamicElement)
-        {
-            return ((DynamicElement)value).getName();
-        }
-        return ""; //$NON-NLS-1$
-    }
-
-    public Translator[] getDynamicAttributeTranslators(Node element) {
-        NamedNodeMap attributeMap = element.getAttributes();
-        List attributes = new ArrayList(attributeMap.getLength());
-        for (int i = 0; i < attributeMap.getLength(); i++)
-        {
-            Attr attr = (Attr) attributeMap.item(i);
-            attributes.add(
-                    new DynamicAttributeTranslator(attr.getNodeName(),
-                            FacesConfigPackage.eINSTANCE.getDynamicElement_Attributes()));
-        }
-        
-        return (Translator[]) attributes.toArray(new Translator[0]);
-    }
-    
-    public Translator[] getDynamicAttributeTranslators(DynamicElement element) {
-        List attributes = element.getAttributes();
-        Translator[] translators = new Translator[attributes.size()];
-        int i = 0;
-        for (Iterator it = attributes.iterator(); it.hasNext();)
-        {
-            DynamicAttribute attribute = (DynamicAttribute) it.next();
-            translators[i++] = new DynamicAttributeTranslator(attribute.getName(),
-                    FacesConfigPackage.eINSTANCE.getDynamicElement_Attributes());
-        }
-        return translators;
-    }
-
-    private static class DynamicAttributeTranslator extends Translator
-    {
-
-        /**
-         * @param domNameAndPath
-         * @param feature
-         */
-        public DynamicAttributeTranslator(String domNameAndPath, EStructuralFeature feature) 
-        {
-            // the "*" is a place holder.  The dom path gets ignored in
-            // this translator.  It's a handy one because it is invalid
-            // tag name data so if it gets transmitted to the model
-            // we will get an exception
-            super(domNameAndPath, feature, DOM_ATTRIBUTE);
-        }
-        
-        public boolean isMapFor(String domName) {
-            return super.isMapFor(domName);
-        }
-        
-        public EObject createEMFObject(String nodeName, String readAheadName) {
-            // attribute name is based on the name property
-            DynamicAttribute attribute = FacesConfigFactory.eINSTANCE.createDynamicAttribute();
-            attribute.setName(nodeName);
-            return attribute;
-        }
-        
-        protected Translator[] getChildren() {
-            return new Translator[0];
-        }
-
-        public void addReadAheadHelper(ReadAheadHelper helper) {
-            // TODO Auto-generated method stub
-            super.addReadAheadHelper(helper);
-        }
-
-        public EObject basicGetDependencyObject(EObject parent) {
-            // TODO Auto-generated method stub
-            return super.basicGetDependencyObject(parent);
-        }
-
-        public void clearList(EObject mofObject) {
-            // TODO Auto-generated method stub
-            super.clearList(mofObject);
-        }
-
-        public Object convertStringToValue(String strValue, EObject owner) {
-            // TODO Auto-generated method stub
-            return super.convertStringToValue(strValue, owner);
-        }
-
-        public Object convertStringToValue(String nodeName,
-                String readAheadName, String value, Notifier owner) {
-            // TODO Auto-generated method stub
-            return super.convertStringToValue(nodeName, readAheadName, value, owner);
-        }
-
-        public String convertValueToString(Object value, EObject owner) {
-            // TODO Auto-generated method stub
-            return super.convertValueToString(value, owner);
-        }
-
-        public boolean equals(Object object) {
-            // TODO Auto-generated method stub
-            return super.equals(object);
-        }
-
-        public String extractStringValue(EObject emfObject) {
-            // TODO Auto-generated method stub
-            return super.extractStringValue(emfObject);
-        }
-
-        public boolean featureExists(EObject emfObject) {
-            // TODO Auto-generated method stub
-            return super.featureExists(emfObject);
-        }
-
-        public Translator findChild(String tagName, Object target, int versionID) {
-            // TODO Auto-generated method stub
-            return super.findChild(tagName, target, versionID);
-        }
-
-        public Translator[] getChildren(Object target, int versionID) {
-            // TODO Auto-generated method stub
-            return super.getChildren(target, versionID);
-        }
-
-        public EStructuralFeature getDependencyFeature() {
-            // TODO Auto-generated method stub
-            return super.getDependencyFeature();
-        }
-
-        public String[] getDOMNames() {
-            // TODO Auto-generated method stub
-            return super.getDOMNames();
-        }
-
-        public String getDOMPath() {
-            // TODO Auto-generated method stub
-            return super.getDOMPath();
-        }
-
-        public EStructuralFeature getFeature() {
-            // TODO Auto-generated method stub
-            return super.getFeature();
-        }
-
-        public List getMOFChildren(EObject mofObject) {
-            // TODO Auto-generated method stub
-            return super.getMOFChildren(mofObject);
-        }
-
-        public Object getMOFValue(EObject mofObject) {
-            if (mofObject instanceof DynamicElement)
-            {
-                EList attributes = ((DynamicElement)mofObject).getAttributes();
-                
-                for (final Iterator it = attributes.iterator(); it.hasNext();)
-                {
-                    DynamicAttribute attribute = (DynamicAttribute) it.next();
-                    if (fDOMNames[0].equals(attribute.getName()))
-                    {
-                        return attribute.getValue();
-                    }
-                }
-            }
-            
-            return null;
-        }
-
-        public String getNameSpace() {
-            // TODO Auto-generated method stub
-            return super.getNameSpace();
-        }
-
-        public ReadAheadHelper getReadAheadHelper(String parentName) {
-            // TODO Auto-generated method stub
-            return super.getReadAheadHelper(parentName);
-        }
-
-        public TranslatorPath[] getTranslatorPaths() {
-            // TODO Auto-generated method stub
-            return super.getTranslatorPaths();
-        }
-
-        public Translator[] getVariableChildren(Notifier target, int version) {
-            // TODO Auto-generated method stub
-            return super.getVariableChildren(target, version);
-        }
-
-        public VariableTranslatorFactory getVariableTranslatorFactory() {
-            // TODO Auto-generated method stub
-            return super.getVariableTranslatorFactory();
-        }
-
-        public boolean hasDOMPath() {
-            // TODO Auto-generated method stub
-            return super.hasDOMPath();
-        }
-
-        public boolean hasReadAheadNames() {
-            // TODO Auto-generated method stub
-            return super.hasReadAheadNames();
-        }
-
-        protected void initializeDOMNameAndPath(String domNameAndPathArg) {
-            // TODO Auto-generated method stub
-            super.initializeDOMNameAndPath(domNameAndPathArg);
-        }
-
-        public boolean isBooleanFeature() {
-            // TODO Auto-generated method stub
-            return super.isBooleanFeature();
-        }
-
-        public boolean isBooleanUppercase() {
-            // TODO Auto-generated method stub
-            return super.isBooleanUppercase();
-        }
-
-        public boolean isCDATAContent() {
-            // TODO Auto-generated method stub
-            return super.isCDATAContent();
-        }
-
-        public boolean isComment() {
-            // TODO Auto-generated method stub
-            return super.isComment();
-        }
-
-        public boolean isDataType() {
-            // TODO Auto-generated method stub
-            return super.isDataType();
-        }
-
-        public boolean isDependencyChild() {
-            // TODO Auto-generated method stub
-            return super.isDependencyChild();
-        }
-
-        public boolean isDependencyParent() {
-            // TODO Auto-generated method stub
-            return super.isDependencyParent();
-        }
-
-        public boolean isDOMAttribute() {
-            // TODO Auto-generated method stub
-            return super.isDOMAttribute();
-        }
-
-        public boolean isDOMTextValue() {
-            // TODO Auto-generated method stub
-            return super.isDOMTextValue();
-        }
-
-        public boolean isEmptyContentSignificant() {
-            // TODO Auto-generated method stub
-            return super.isEmptyContentSignificant();
-        }
-
-        public boolean isEmptyTag() {
-            // TODO Auto-generated method stub
-            return super.isEmptyTag();
-        }
-
-        public boolean isEnumFeature() {
-            // TODO Auto-generated method stub
-            return super.isEnumFeature();
-        }
-
-        public boolean isEnumWithHyphens() {
-            // TODO Auto-generated method stub
-            return super.isEnumWithHyphens();
-        }
-
-        public boolean isIDMap() {
-            // TODO Auto-generated method stub
-            return super.isIDMap();
-        }
-
-        public boolean isLinkMap() {
-            // TODO Auto-generated method stub
-            return super.isLinkMap();
-        }
-
-        public boolean isManagedByParent() {
-            // TODO Auto-generated method stub
-            return super.isManagedByParent();
-        }
-
-        public boolean isMapFor(Object feature1, Object oldValue, Object newValue) {
-            return super.isMapFor(feature1, oldValue, newValue);
-        }
-
-        public boolean isMultiValued() {
-            // we want to treat each attribute as a single value
-            return false;
-        }
-
-        public boolean isObjectMap() {
-            // TODO Auto-generated method stub
-            return super.isObjectMap();
-        }
-
-        public boolean isSetMOFValue(EObject emfObject) {
-            // TODO Auto-generated method stub
-            return super.isSetMOFValue(emfObject);
-        }
-
-        public boolean isShared() {
-            // TODO Auto-generated method stub
-            return super.isShared();
-        }
-
-        public boolean isTargetLinkMap() {
-            // TODO Auto-generated method stub
-            return super.isTargetLinkMap();
-        }
-
-        public boolean isUnsettable() {
-            // TODO Auto-generated method stub
-            return super.isUnsettable();
-        }
-
-        protected String[] parseDOMNames(String domNamesString) {
-            // TODO Auto-generated method stub
-            return super.parseDOMNames(domNamesString);
-        }
-
-        public void removeMOFValue(Notifier owner, Object value) {
-            // TODO Auto-generated method stub
-            super.removeMOFValue(owner, value);
-        }
-
-        protected void setEMFClass(EClass anEClass) {
-            // TODO Auto-generated method stub
-            super.setEMFClass(anEClass);
-        }
-
-        protected void setFeature(EStructuralFeature feature) {
-            // TODO Auto-generated method stub
-            super.setFeature(feature);
-        }
-
-        public void setMOFValue(Notifier owner, Object value, int newIndex) {
-            if (owner instanceof DynamicElement)
-            {
-                DynamicAttribute attribute = FacesConfigFactory.eINSTANCE.createDynamicAttribute();
-                attribute.setName(fDOMNames[0]);
-                attribute.setValue(value.toString());
-
-                EList attributes = ((DynamicElement)owner).getAttributes();
-                if (newIndex < 0 || newIndex >= attributes.size())
-                {
-                    attributes.add(attribute);
-                }
-                else
-                {
-                    attributes.set(newIndex, attribute);
-                }
-            }
-            // otherwise do nothing
-        }
-
-        public void setMOFValue(Notifier owner, Object value) {
-            // TODO Auto-generated method stub
-            super.setMOFValue(owner, value);
-        }
-
-        public void setMOFValue(Resource res, Object value) {
-            // TODO Auto-generated method stub
-            super.setMOFValue(res, value);
-        }
-
-        public void setMOFValueFromEmptyDOMPath(EObject object) {
-            // TODO Auto-generated method stub
-            super.setMOFValueFromEmptyDOMPath(object);
-        }
-
-        public void setNameSpace(String string) {
-            // TODO Auto-generated method stub
-            super.setNameSpace(string);
-        }
-
-        public void setTextValueIfNecessary(String textValue, Notifier owner,
-                int versionId) {
-            // TODO Auto-generated method stub
-            super.setTextValueIfNecessary(textValue, owner, versionId);
-        }
-
-        public boolean shouldIndentEndTag() {
-            // TODO Auto-generated method stub
-            return super.shouldIndentEndTag();
-        }
-
-        public boolean shouldRenderEmptyDOMPath(EObject object) {
-            // TODO Auto-generated method stub
-            return super.shouldRenderEmptyDOMPath(object);
-        }
-
-        public String toString() {
-            // TODO Auto-generated method stub
-            return super.toString();
-        }
-
-        public void unSetMOFValue(EObject emfObject) {
-            // TODO Auto-generated method stub
-            super.unSetMOFValue(emfObject);
-        }
-        
-        
-    }
-}
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ELResolverTypeTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ELResolverTypeTranslator.java
deleted file mode 100644
index 96b0548..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ELResolverTypeTranslator.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * The el-resolver translator
- *
- */
-public class ELResolverTypeTranslator extends Translator {
-    /**
-     * @param domNameAndPath
-     * @param aFeature
-     */
-    public ELResolverTypeTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-        super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-    }
-
-    /* (non-Javadoc)
-     * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-     */
-    public Translator[] getChildren() {
-        
-        FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-        return new Translator[] {
-            new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getELResolverType_TextContent()),
-            new Translator("id", facesPackage.getELResolverType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-        };
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ExceptionHandlerFactoryTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ExceptionHandlerFactoryTranslator.java
deleted file mode 100644
index 41a24fe..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ExceptionHandlerFactoryTranslator.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class ExceptionHandlerFactoryTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ExceptionHandlerFactoryTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/*  (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getExceptionHandlerFactoryType_TextContent()),
-			new Translator("id", facesPackage.getExceptionHandlerFactoryType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ExtensionTypeTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ExtensionTypeTranslator.java
deleted file mode 100644
index eca0e57..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ExtensionTypeTranslator.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for extension types
- *
- */
-public abstract class ExtensionTypeTranslator extends Translator 
-{
-    /**
-     * @param domNameAndPath
-     * @param aFeature
-     */
-    public ExtensionTypeTranslator(String domNameAndPath, EStructuralFeature aFeature) 
-    {
-        super(domNameAndPath, aFeature);
-    }
-    
-    public Translator[] getChildren() {
-        
-        FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-        return new Translator[] {
-              new Translator("id", facesPackage.getExtensionType_Id(), DOM_ATTRIBUTE), //$NON-NLS-1$
-              new DynamicElementTranslator("*", facesPackage.getExtensionType_ChildNodes()) //$NON-NLS-1$
-        };
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ExternalContextFactoryTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ExternalContextFactoryTranslator.java
deleted file mode 100644
index 7103916..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ExternalContextFactoryTranslator.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class ExternalContextFactoryTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ExternalContextFactoryTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/*  (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getExternalContextFactoryType_TextContent()),
-			new Translator("id", facesPackage.getExternalContextFactoryType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FacesConfigExtensionTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FacesConfigExtensionTranslator.java
deleted file mode 100644
index b5819cb..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FacesConfigExtensionTranslator.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-/**
- * Translator for FacesConfig extension data
- *
- */
-public class FacesConfigExtensionTranslator extends ExtensionTypeTranslator {
-
-    /**
-     * @param domNameAndPath
-     * @param feature
-     */
-    public FacesConfigExtensionTranslator(String domNameAndPath,
-            EStructuralFeature feature) {
-        super(domNameAndPath, feature);
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FacesConfigTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FacesConfigTranslator.java
deleted file mode 100644
index 599927e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FacesConfigTranslator.java
+++ /dev/null
@@ -1,64 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.RootTranslator;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class FacesConfigTranslator extends RootTranslator {
-	
-	/**
-	 * Instance of translator
-	 */
-	public static FacesConfigTranslator INSTANCE = new FacesConfigTranslator();
-
-    /**
-     * Default constructor
-     */
-    public FacesConfigTranslator() {
-		super("faces-config", FacesConfigPackage.eINSTANCE.getFacesConfigType()); //$NON-NLS-1$
-    }
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-				new ApplicationTranslator("application", facesPackage.getFacesConfigType_Application()), //$NON-NLS-1$
-				new OrderingTranslator("ordering", facesPackage.getFacesConfigType_Ordering()), //$NON-NLS-1$
-				new AbsoluteOrderingTranslator("absolute-ordering", facesPackage.getFacesConfigType_AbsoluteOrdering()), //$NON-NLS-1$
-				new FactoryTranslator("factory", facesPackage.getFacesConfigType_Factory()), //$NON-NLS-1$
-				new ComponentTranslator("component", facesPackage.getFacesConfigType_Component()), //$NON-NLS-1$
-				new ConverterTranslator("converter", facesPackage.getFacesConfigType_Converter()), //$NON-NLS-1$
-				new ManagedBeanTranslator("managed-bean", facesPackage.getFacesConfigType_ManagedBean()), //$NON-NLS-1$
-				new NameTranslator("name", facesPackage.getFacesConfigType_Name()), //$NON-NLS-1$
-				new NavigationRuleTranslator("navigation-rule", facesPackage.getFacesConfigType_NavigationRule()), //$NON-NLS-1$
-				new ReferencedBeanTranslator("referenced-bean", facesPackage.getFacesConfigType_ReferencedBean()), //$NON-NLS-1$
-				new RenderKitTranslator("render-kit", facesPackage.getFacesConfigType_RenderKit()), //$NON-NLS-1$
-				new LifecycleTranslator("lifecycle", facesPackage.getFacesConfigType_Lifecycle()), //$NON-NLS-1$
-				new ValidatorTranslator("validator", facesPackage.getFacesConfigType_Validator()), //$NON-NLS-1$
-				new BehaviorTranslator("behavior", facesPackage.getFacesConfigType_Behavior()), //$NON-NLS-1$
-				new FacesConfigExtensionTranslator("faces-config-extension", facesPackage.getFacesConfigType_FacesConfigExtension()), //$NON_NLS-1$ //$NON-NLS-1$
-				new Translator("xmlns", facesPackage.getFacesConfigType_Xmlns(), DOM_ATTRIBUTE), //$NON-NLS-1$
-				new Translator("metadata-complete", facesPackage.getFacesConfigType_MetadataComplete(), DOM_ATTRIBUTE), //$NON-NLS-1$
-				new Translator("id", facesPackage.getFacesConfigType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FacesContextFactoryTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FacesContextFactoryTranslator.java
deleted file mode 100644
index 8ad0eda..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FacesContextFactoryTranslator.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang, itrimble
- *
- */
-public class FacesContextFactoryTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public FacesContextFactoryTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getFacesContextFactoryType_TextContent()),
-			new Translator("id", facesPackage.getFacesContextFactoryType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FacetExtensionTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FacetExtensionTranslator.java
deleted file mode 100644
index 3cffc06..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FacetExtensionTranslator.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Orcale Corporation - fixed getChildren()
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-/**
- * @author xnjiang, itrimble
- *
- */
-public class FacetExtensionTranslator extends ExtensionTypeTranslator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public FacetExtensionTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FacetNameTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FacetNameTranslator.java
deleted file mode 100644
index 81e5023..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FacetNameTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for facet name
- *
- */
-public class FacetNameTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public FacetNameTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getFacetNameType_TextContent()),
-			new Translator("id", facesPackage.getFacetNameType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FacetTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FacetTranslator.java
deleted file mode 100644
index 52f7b1f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FacetTranslator.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - fixed getChildren()
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang, itrimble
- *
- */
-public class FacetTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public FacetTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new DescriptionTranslator("description", facesPackage.getFacetType_Description()), //$NON-NLS-1$
-			new DisplayNameTranslator("display-name", facesPackage.getFacetType_DisplayName()), //$NON-NLS-1$
-			new IconTranslator("icon", facesPackage.getFacetType_Icon()), //$NON-NLS-1$
-			new FacetNameTranslator("facet-name", facesPackage.getFacetType_FacetName()), //$NON-NLS-1$
-			new FacetExtensionTranslator("facet-extension", facesPackage.getFacetType_FacetExtension()), //$NON-NLS-1$
-			new Translator("id", facesPackage.getFacetType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FactoryExtensionTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FactoryExtensionTranslator.java
deleted file mode 100644
index 0bdd623..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FactoryExtensionTranslator.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-/**
- * The factory extension translator
- *
- */
-public class FactoryExtensionTranslator extends ExtensionTypeTranslator {
-
-    /**
-     * @param domNameAndPath
-     * @param feature
-     */
-    public FactoryExtensionTranslator(String domNameAndPath,
-            EStructuralFeature feature) {
-        super(domNameAndPath, feature);
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FactoryTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FactoryTranslator.java
deleted file mode 100644
index c49a70c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FactoryTranslator.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author Eric Bordeau, itrimble
- */
-public class FactoryTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public FactoryTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new ApplicationFactoryTranslator("application-factory", facesPackage.getFactoryType_ApplicationFactory()), //$NON-NLS-1$
-			new ExceptionHandlerFactoryTranslator("exception-handler-factory", facesPackage.getFactoryType_ExceptionHandlerFactory()), //$NON-NLS-1$
-			new ExternalContextFactoryTranslator("external-context-factory", facesPackage.getFactoryType_ExternalContextFactory()), //$NON-NLS-1$
-			new FacesContextFactoryTranslator("faces-context-factory", facesPackage.getFactoryType_FacesContextFactory()), //$NON-NLS-1$
-			new PartialViewContextFactoryTranslator("partial-view-context-factory", facesPackage.getFactoryType_PartialViewContextFactory()), //$NON-NLS-1$
-			new LifecycleFactoryTranslator("lifecycle-factory", facesPackage.getFactoryType_LifecycleFactory()), //$NON-NLS-1$
-			new ViewDeclarationLanguageFactoryTranslator("view-declaration-language-factory", facesPackage.getFactoryType_ViewDeclarationLanguageFactory()), //$NON-NLS-1$
-			new TagHandlerDelegateFactoryTranslator("tag-handler-delegate-factory", facesPackage.getFactoryType_TagHandlerDelegateFactory()), //$NON-NLS-1$
-			new RenderKitFactoryTranslator("render-kit-factory", facesPackage.getFactoryType_RenderKitFactory()), //$NON-NLS-1$
-			new VisitContextFactoryTranslator("visit-context-factory", facesPackage.getFactoryType_VisitContextFactory()), //$NON-NLS-1$
-            new FactoryExtensionTranslator("factory-extension", facesPackage.getFactoryType_FactoryExtension()), //$NON-NLS-1$
-			new Translator("id", facesPackage.getFactoryType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FromActionTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FromActionTranslator.java
deleted file mode 100644
index b792ce8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FromActionTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for FromAction
- *
- */
-public class FromActionTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public FromActionTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getFromActionType_TextContent()),
-			new Translator("id", facesPackage.getFromActionType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FromOutcomeTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FromOutcomeTranslator.java
deleted file mode 100644
index 9779b41..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FromOutcomeTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for FromOutcome
- *
- */
-public class FromOutcomeTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public FromOutcomeTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getFromOutcomeType_TextContent()),
-			new Translator("id", facesPackage.getFromOutcomeType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FromViewIdTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FromViewIdTranslator.java
deleted file mode 100644
index 2616e4a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/FromViewIdTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for FromViewId
- *
- */
-public class FromViewIdTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public FromViewIdTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getFromViewIdType_TextContent()),
-			new Translator("id", facesPackage.getFromViewIdType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/IAnyTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/IAnyTranslator.java
deleted file mode 100644
index 06d0757..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/IAnyTranslator.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.jst.jsf.facesconfig.emf.DynamicElement;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-import org.w3c.dom.Node;
-
-/**
- * A translator that can handle the DTD ANY and XSD anyType XML
- * 
- * @author cbateman
- *
- */
-public interface IAnyTranslator {
-    /**
-     * Allows an ANY translator for elements to 
-     * dynamically inject attribute translators
-     * based on the contents of the Element node's
-     * runtime attribute values
-     * 
-     * @param element 
-     * @return a list of translators for attributes
-     * of dynamic elements
-     */
-    Translator[]  getDynamicAttributeTranslators(Node element);
-    
-    /**
-     * Allows an ANY translator for elements to
-     * dynamically inject attribute translators
-     * based on the contents of an DynamicElement that
-     * may not already be in the corresponding DOM element
-     * 
-     * @param element
-     * @return a list of translators for attributes of dynamic elements
-     */
-    Translator[]  getDynamicAttributeTranslators(DynamicElement element);
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/IconTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/IconTranslator.java
deleted file mode 100644
index 9f33f6a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/IconTranslator.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - fixed getChildren()
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class IconTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public IconTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new SmallIconTranslator("small-icon", facesPackage.getIconType_SmallIcon()), //$NON-NLS-1$
-			new LargeIconTranslator("large-icon", facesPackage.getIconType_LargeIcon()), //$NON-NLS-1$
-			new Translator("xml:lang", facesPackage.getIconType_Lang(), DOM_ATTRIBUTE), //$NON-NLS-1$
-			new Translator("id", facesPackage.getIconType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/IfTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/IfTranslator.java
deleted file mode 100644
index 3016a6b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/IfTranslator.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class IfTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public IfTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/*  (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getIfType_TextContent()),
-			new Translator("id", facesPackage.getIfType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/KeyClassTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/KeyClassTranslator.java
deleted file mode 100644
index 1c8f904..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/KeyClassTranslator.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for key class property
- * 
- * @author cbateman
- *
- */
-public class KeyClassTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public KeyClassTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getKeyClassType_TextContent()),
-			new Translator("id", facesPackage.getKeyClassType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/KeyTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/KeyTranslator.java
deleted file mode 100644
index 6d7f354..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/KeyTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for key property
- *
- */
-public class KeyTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public KeyTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getKeyType_TextContent()),
-			new Translator("id", facesPackage.getKeyType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/LargeIconTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/LargeIconTranslator.java
deleted file mode 100644
index 0c7e44c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/LargeIconTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for large icon property
- *
- */
-public class LargeIconTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public LargeIconTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getLargeIconType_TextContent()),
-			new Translator("id", facesPackage.getLargeIconType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/LifecycleExtensionTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/LifecycleExtensionTranslator.java
deleted file mode 100644
index c5c9f2d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/LifecycleExtensionTranslator.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-/**
- * Translator for lifecycle extensions
- *
- */
-public class LifecycleExtensionTranslator extends ExtensionTypeTranslator {
-
-    /**
-     * @param domNameAndPath
-     * @param feature
-     */
-    public LifecycleExtensionTranslator(String domNameAndPath,
-            EStructuralFeature feature) {
-        super(domNameAndPath, feature);
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/LifecycleFactoryTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/LifecycleFactoryTranslator.java
deleted file mode 100644
index 0d06154..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/LifecycleFactoryTranslator.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang, itrimble
- *
- */
-public class LifecycleFactoryTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public LifecycleFactoryTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getLifecycleFactoryType_TextContent()),
-			new Translator("id", facesPackage.getLifecycleFactoryType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/LifecycleTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/LifecycleTranslator.java
deleted file mode 100644
index c36905e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/LifecycleTranslator.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author Eric Bordeau, itrimble
- */
-public class LifecycleTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public LifecycleTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new PhaseListenerTranslator("phase-listener", facesPackage.getLifecycleType_PhaseListener()), //$NON-NLS-1$
-            new LifecycleExtensionTranslator("lifecycle-extension",facesPackage.getLifecycleType_LifecycleExtension()), //$NON-NLS-1$
-			new Translator("id", facesPackage.getLifecycleType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ListEntriesTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ListEntriesTranslator.java
deleted file mode 100644
index c2093a5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ListEntriesTranslator.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - fixed getChildren()
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class ListEntriesTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ListEntriesTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new ValueClassTranslator("value-class", facesPackage.getListEntriesType_ValueClass()), //$NON-NLS-1$
-			new NullValueTranslator("null-value", facesPackage.getListEntriesType_NullValue()), //$NON-NLS-1$
-			new ValueTranslator("value", facesPackage.getListEntriesType_Value()), //$NON-NLS-1$
-			new Translator("id", facesPackage.getListEntriesType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/LocaleConfigTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/LocaleConfigTranslator.java
deleted file mode 100644
index caed4ae..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/LocaleConfigTranslator.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - fixed getChildren()
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class LocaleConfigTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public LocaleConfigTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new DefaultLocaleTranslator("default-locale", facesPackage.getLocaleConfigType_DefaultLocale()), //$NON-NLS-1$
-			new SupportedLocaleTranslator("supported-locale", facesPackage.getLocaleConfigType_SupportedLocale()), //$NON-NLS-1$
-			new Translator("id", facesPackage.getLocaleConfigType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ManagedBeanClassTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ManagedBeanClassTranslator.java
deleted file mode 100644
index 2317987..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ManagedBeanClassTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for the managed bean class
- *
- */
-public class ManagedBeanClassTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ManagedBeanClassTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getManagedBeanClassType_TextContent()),
-			new Translator("id", facesPackage.getManagedBeanClassType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ManagedBeanExtensionTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ManagedBeanExtensionTranslator.java
deleted file mode 100644
index e3d967a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ManagedBeanExtensionTranslator.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-/**
- * Translator for managed bean extensions
- *
- */
-public class ManagedBeanExtensionTranslator extends ExtensionTypeTranslator {
-
-    /**
-     * @param domNameAndPath
-     * @param feature
-     */
-    public ManagedBeanExtensionTranslator(String domNameAndPath,
-            EStructuralFeature feature) {
-        super(domNameAndPath, feature);
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ManagedBeanNameTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ManagedBeanNameTranslator.java
deleted file mode 100644
index d2ded7c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ManagedBeanNameTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for managed bean name
- *
- */
-public class ManagedBeanNameTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ManagedBeanNameTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getManagedBeanNameType_TextContent()),
-			new Translator("id", facesPackage.getManagedBeanNameType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ManagedBeanScopeTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ManagedBeanScopeTranslator.java
deleted file mode 100644
index 7138a6d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ManagedBeanScopeTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for managed bean scope
- *
- */
-public class ManagedBeanScopeTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ManagedBeanScopeTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getManagedBeanScopeType_TextContent()),
-			new Translator("id", facesPackage.getManagedBeanScopeType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ManagedBeanTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ManagedBeanTranslator.java
deleted file mode 100644
index c306f6c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ManagedBeanTranslator.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - fixed getChildren()
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class ManagedBeanTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ManagedBeanTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new DescriptionTranslator("description", facesPackage.getManagedBeanType_Description()), //$NON-NLS-1$
-			new DisplayNameTranslator("display-name", facesPackage.getManagedBeanType_DisplayName()), //$NON-NLS-1$
-			new IconTranslator("icon", facesPackage.getManagedBeanType_Icon()), //$NON-NLS-1$
-			new ManagedBeanNameTranslator("managed-bean-name", facesPackage.getManagedBeanType_ManagedBeanName()), //$NON-NLS-1$
-			new ManagedBeanClassTranslator("managed-bean-class", facesPackage.getManagedBeanType_ManagedBeanClass()), //$NON-NLS-1$
-			new ManagedBeanScopeTranslator("managed-bean-scope", facesPackage.getManagedBeanType_ManagedBeanScope()), //$NON-NLS-1$
-			new ManagedPropertyTranslator("managed-property", facesPackage.getManagedBeanType_ManagedProperty()), //$NON-NLS-1$
-			new MapEntriesTranslator("map-entries", facesPackage.getManagedBeanType_MapEntries()), //$NON-NLS-1$
-			new ListEntriesTranslator("list-entries", facesPackage.getManagedBeanType_ListEntries()), //$NON-NLS-1$
-            new ManagedBeanExtensionTranslator("managed-bean-extension", facesPackage.getManagedBeanType_ManagedBeanExtension()), //$NON-NLS-1$
-			new Translator("eager", facesPackage.getManagedBeanType_Eager(), DOM_ATTRIBUTE), //$NON-NLS-1$
-			new Translator("id", facesPackage.getManagedBeanType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ManagedPropertyTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ManagedPropertyTranslator.java
deleted file mode 100644
index 49198cb..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ManagedPropertyTranslator.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - fixed getChildren()
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class ManagedPropertyTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ManagedPropertyTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new DescriptionTranslator("description", facesPackage.getManagedPropertyType_Description()), //$NON-NLS-1$
-			new DisplayNameTranslator("display-name", facesPackage.getManagedPropertyType_DisplayName()), //$NON-NLS-1$
-			new IconTranslator("icon", facesPackage.getManagedPropertyType_Icon()), //$NON-NLS-1$
-			new PropertyNameTranslator("property-name", facesPackage.getManagedPropertyType_PropertyName()), //$NON-NLS-1$
-			new PropertyClassTranslator("property-class", facesPackage.getManagedPropertyType_PropertyClass()), //$NON-NLS-1$
-			new MapEntriesTranslator("map-entries", facesPackage.getManagedPropertyType_MapEntries()), //$NON-NLS-1$
-			new NullValueTranslator("null-value", facesPackage.getManagedPropertyType_NullValue()), //$NON-NLS-1$
-			new ValueTranslator("value", facesPackage.getManagedPropertyType_Value()), //$NON-NLS-1$
-			new ListEntriesTranslator("list-entries", facesPackage.getManagedPropertyType_ListEntries()), //$NON-NLS-1$
-			new Translator("id", facesPackage.getManagedPropertyType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/MapEntriesTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/MapEntriesTranslator.java
deleted file mode 100644
index 40faec1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/MapEntriesTranslator.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - fixed getChildren()
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class MapEntriesTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public MapEntriesTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new KeyClassTranslator("key-class", facesPackage.getMapEntriesType_KeyClass()), //$NON-NLS-1$
-			new ValueClassTranslator("value-class", facesPackage.getMapEntriesType_ValueClass()), //$NON-NLS-1$
-			new MapEntryTranslator("map-entry", facesPackage.getMapEntriesType_MapEntry()), //$NON-NLS-1$
-			new Translator("id", facesPackage.getMapEntriesType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/MapEntryTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/MapEntryTranslator.java
deleted file mode 100644
index d571502..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/MapEntryTranslator.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - fixed getChildren()
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class MapEntryTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public MapEntryTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new KeyTranslator("key", facesPackage.getMapEntryType_Key()), //$NON-NLS-1$
-			new NullValueTranslator("null-value", facesPackage.getMapEntryType_NullValue()), //$NON-NLS-1$
-			new ValueTranslator("value", facesPackage.getMapEntryType_Value()), //$NON-NLS-1$
-			new Translator("id", facesPackage.getMapEntryType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/MessageBundleTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/MessageBundleTranslator.java
deleted file mode 100644
index d052df6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/MessageBundleTranslator.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class MessageBundleTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public MessageBundleTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getMessageBundleType_TextContent()),
-			new Translator("id", facesPackage.getMessageBundleType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/NameTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/NameTranslator.java
deleted file mode 100644
index 96bf3ba..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/NameTranslator.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class NameTranslator extends Translator {
-	/**
-	 * @param domNameAndPath 
-	 * @param aFeature 
-	 */
-	public NameTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getNameType_TextContent()),
-			new Translator("id", facesPackage.getNameType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/NavigationCaseTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/NavigationCaseTranslator.java
deleted file mode 100644
index 4d14702..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/NavigationCaseTranslator.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - fixed getChildren()
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class NavigationCaseTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public NavigationCaseTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new DescriptionTranslator("description", facesPackage.getNavigationCaseType_Description()), //$NON-NLS-1$
-			new DisplayNameTranslator("display-name", facesPackage.getNavigationCaseType_DisplayName()), //$NON-NLS-1$
-			new IconTranslator("icon", facesPackage.getNavigationCaseType_Icon()), //$NON-NLS-1$
-			new FromActionTranslator("from-action", facesPackage.getNavigationCaseType_FromAction()), //$NON-NLS-1$
-			new FromOutcomeTranslator("from-outcome", facesPackage.getNavigationCaseType_FromOutcome()), //$NON-NLS-1$
-			new IfTranslator("if", facesPackage.getNavigationCaseType_If()), //$NON-NLS-1$
-			new ToViewIdTranslator("to-view-id", facesPackage.getNavigationCaseType_ToViewId()), //$NON-NLS-1$
-			new RedirectTranslator("redirect", facesPackage.getNavigationCaseType_Redirect()), //$NON-NLS-1$
-			new Translator("id", facesPackage.getNavigationCaseType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/NavigationHandlerTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/NavigationHandlerTranslator.java
deleted file mode 100644
index 694a009..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/NavigationHandlerTranslator.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class NavigationHandlerTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public NavigationHandlerTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getNavigationHandlerType_TextContent()),
-			new Translator("id", facesPackage.getNavigationHandlerType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/NavigationRuleExtensionTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/NavigationRuleExtensionTranslator.java
deleted file mode 100644
index f1c02f7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/NavigationRuleExtensionTranslator.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-/**
- * Translator for navigation rule extensions
- *
- */
-public class NavigationRuleExtensionTranslator extends ExtensionTypeTranslator {
-
-    /**
-     * @param domNameAndPath
-     * @param feature
-     */
-    public NavigationRuleExtensionTranslator(String domNameAndPath,
-            EStructuralFeature feature) {
-        super(domNameAndPath, feature);
-    }
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/NavigationRuleTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/NavigationRuleTranslator.java
deleted file mode 100644
index f808698..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/NavigationRuleTranslator.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - fixed getChildren()
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class NavigationRuleTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public NavigationRuleTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new DescriptionTranslator("description", facesPackage.getNavigationRuleType_Description()), //$NON-NLS-1$
-			new DisplayNameTranslator("display-name", facesPackage.getNavigationRuleType_DisplayName()), //$NON-NLS-1$
-			new IconTranslator("icon", facesPackage.getNavigationRuleType_Icon()), //$NON-NLS-1$
-			new FromViewIdTranslator("from-view-id", facesPackage.getNavigationRuleType_FromViewId()), //$NON-NLS-1$
-			new NavigationCaseTranslator("navigation-case", facesPackage.getNavigationRuleType_NavigationCase()), //$NON-NLS-1$
-            new NavigationRuleExtensionTranslator("navigation-rule-extension", facesPackage.getNavigationRuleType_NavigationRuleExtension()), //$NON-NLS-1$
-			new Translator("id", facesPackage.getNavigationRuleType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/NullValueTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/NullValueTranslator.java
deleted file mode 100644
index e4507cd..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/NullValueTranslator.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class NullValueTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public NullValueTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, EMPTY_TAG|END_TAG_NO_INDENT);
-	}
-
-	public boolean isSetMOFValue(EObject emfObject) {
-		return feature != null && emfObject.eIsSet(feature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator("id", facesPackage.getNullValueType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/OrderingOrderingTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/OrderingOrderingTranslator.java
deleted file mode 100644
index 3fd4531..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/OrderingOrderingTranslator.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang, itrimble
- *
- */
-public class OrderingOrderingTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public OrderingOrderingTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-				new NameTranslator("name", facesPackage.getOrderingOrderingType_Name()), //$NON-NLS-1$
-				new OrderingOthersTranslator("others", facesPackage.getOrderingOrderingType_Others()) //$NON-NLS-1$
-//				new Translator("id", facesPackage.getOrderingOrderingType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/OrderingOthersTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/OrderingOthersTranslator.java
deleted file mode 100644
index f7ab410..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/OrderingOthersTranslator.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class OrderingOthersTranslator extends Translator {
-	/**
-	 * @param domNameAndPath 
-	 * @param aFeature 
-	 */
-	public OrderingOthersTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator("id", facesPackage.getOrderingOthersType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/OrderingTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/OrderingTranslator.java
deleted file mode 100644
index 2aedd02..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/OrderingTranslator.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang, itrimble
- *
- */
-public class OrderingTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public OrderingTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-				new OrderingOrderingTranslator("after", facesPackage.getOrderingType_After()), //$NON-NLS-1$
-				new OrderingOrderingTranslator("before", facesPackage.getOrderingType_Before()) //$NON-NLS-1$
-//				new Translator("id", facesPackage.getOrderingType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PartialTraversalTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PartialTraversalTranslator.java
deleted file mode 100644
index 02a8cef..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PartialTraversalTranslator.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class PartialTraversalTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public PartialTraversalTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/*  (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		return new Translator[]{};
-//		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-//		return new Translator[] {
-//			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getPartialTraversalType_TextContent()),
-//			new Translator("id", facesPackage.getPartialTraversalType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-//		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PartialViewContextFactoryTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PartialViewContextFactoryTranslator.java
deleted file mode 100644
index 0d1dc27..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PartialViewContextFactoryTranslator.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class PartialViewContextFactoryTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public PartialViewContextFactoryTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/*  (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getPartialViewContextFactoryType_TextContent()),
-			new Translator("id", facesPackage.getPartialViewContextFactoryType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PhaseListenerTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PhaseListenerTranslator.java
deleted file mode 100644
index 61bf6d9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PhaseListenerTranslator.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang, itrimble
- *
- */
-public class PhaseListenerTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public PhaseListenerTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getPhaseListenerType_TextContent()),
-			new Translator("id", facesPackage.getPhaseListenerType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PropertyClassTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PropertyClassTranslator.java
deleted file mode 100644
index 460d1dd..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PropertyClassTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for the property class
- *
- */
-public class PropertyClassTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public PropertyClassTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getPropertyClassType_TextContent()),
-			new Translator("id", facesPackage.getPropertyClassType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PropertyExtensionTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PropertyExtensionTranslator.java
deleted file mode 100644
index 8889939..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PropertyExtensionTranslator.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-/**
- * @author xnjiang, itrimble
- *
- */
-public class PropertyExtensionTranslator extends ExtensionTypeTranslator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public PropertyExtensionTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PropertyNameTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PropertyNameTranslator.java
deleted file mode 100644
index d07de28..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PropertyNameTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for the property name
- *
- */
-public class PropertyNameTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public PropertyNameTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getPropertyNameType_TextContent()),
-			new Translator("id", facesPackage.getPropertyNameType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PropertyResolverTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PropertyResolverTranslator.java
deleted file mode 100644
index 5f5482d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PropertyResolverTranslator.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class PropertyResolverTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public PropertyResolverTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getPropertyResolverType_TextContent()),
-			new Translator("id", facesPackage.getPropertyResolverType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PropertyTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PropertyTranslator.java
deleted file mode 100644
index e01af4d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/PropertyTranslator.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - fixed getChildren()
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class PropertyTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public PropertyTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new DescriptionTranslator("description", facesPackage.getPropertyType_Description()), //$NON-NLS-1$
-			new DisplayNameTranslator("display-name", facesPackage.getPropertyType_DisplayName()), //$NON-NLS-1$
-			new IconTranslator("icon", facesPackage.getPropertyType_Icon()), //$NON-NLS-1$
-			new PropertyNameTranslator("property-name", facesPackage.getPropertyType_PropertyName()), //$NON-NLS-1$
-			new PropertyClassTranslator("property-class", facesPackage.getPropertyType_PropertyClass()), //$NON-NLS-1$
-			new DefaultValueTranslator("default-value", facesPackage.getPropertyType_DefaultValue()), //$NON-NLS-1$
-			new SuggestedValueTranslator("suggested-value", facesPackage.getPropertyType_SuggestedValue()), //$NON-NLS-1$
-			new PropertyExtensionTranslator("property-extension", facesPackage.getPropertyType_PropertyExtension()), //$NON-NLS-1$
-			new Translator("id", facesPackage.getPropertyType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RedirectTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RedirectTranslator.java
deleted file mode 100644
index d86d9c9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RedirectTranslator.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for the redirect
- *
- */
-public class RedirectTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public RedirectTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, EMPTY_TAG|END_TAG_NO_INDENT);
-	}
-
-	public boolean isSetMOFValue(EObject emfObject) {
-		return feature != null && emfObject.eIsSet(feature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new RedirectViewParamTranslator("view-param", facesPackage.getRedirectType_ViewParam()), //$NON-NLS-1$
-			new Translator("include-view-params", facesPackage.getRedirectType_IncludeViewParams(), DOM_ATTRIBUTE), //$NON-NLS-1$
-			new Translator("id", facesPackage.getRedirectType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RedirectViewParamTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RedirectViewParamTranslator.java
deleted file mode 100644
index 3ebe617..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RedirectViewParamTranslator.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang, itrimble
- *
- */
-public class RedirectViewParamTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public RedirectViewParamTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-				new NameTranslator("name", facesPackage.getRedirectViewParamType_Name()), //$NON-NLS-1$
-				new ValueTranslator("value", facesPackage.getRedirectViewParamType_Value()), //$NON-NLS-1$
-				new Translator("id", facesPackage.getRedirectViewParamType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ReferencedBeanClassTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ReferencedBeanClassTranslator.java
deleted file mode 100644
index 2e265d7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ReferencedBeanClassTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for the reference bean class
- *
- */
-public class ReferencedBeanClassTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ReferencedBeanClassTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getReferencedBeanClassType_TextContent()),
-			new Translator("id", facesPackage.getReferencedBeanClassType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ReferencedBeanNameTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ReferencedBeanNameTranslator.java
deleted file mode 100644
index b830b2e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ReferencedBeanNameTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for the referenced bean name
- *
- */
-public class ReferencedBeanNameTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ReferencedBeanNameTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getReferencedBeanNameType_TextContent()),
-			new Translator("id", facesPackage.getReferencedBeanNameType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ReferencedBeanTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ReferencedBeanTranslator.java
deleted file mode 100644
index 4b985c6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ReferencedBeanTranslator.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - fixed getChildren()
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class ReferencedBeanTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ReferencedBeanTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new DescriptionTranslator("description", facesPackage.getReferencedBeanType_Description()), //$NON-NLS-1$
-			new DisplayNameTranslator("display-name", facesPackage.getReferencedBeanType_DisplayName()), //$NON-NLS-1$
-			new IconTranslator("icon", facesPackage.getReferencedBeanType_Icon()), //$NON-NLS-1$
-			new ReferencedBeanNameTranslator("referenced-bean-name", facesPackage.getReferencedBeanType_ReferencedBeanName()), //$NON-NLS-1$
-			new ReferencedBeanClassTranslator("referenced-bean-class", facesPackage.getReferencedBeanType_ReferencedBeanClass()), //$NON-NLS-1$
-			new Translator("id", facesPackage.getReferencedBeanType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RenderKitClassTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RenderKitClassTranslator.java
deleted file mode 100644
index a44e046..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RenderKitClassTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for the render kit class property
- *
- */
-public class RenderKitClassTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public RenderKitClassTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getRenderKitClassType_TextContent()),
-			new Translator("id", facesPackage.getRenderKitClassType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RenderKitExtensionTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RenderKitExtensionTranslator.java
deleted file mode 100644
index 54b021e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RenderKitExtensionTranslator.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-/**
- * Translator for the extension to renderkit property
- *
- */
-public class RenderKitExtensionTranslator extends ExtensionTypeTranslator {
-
-    /**
-     * @param domNameAndPath
-     * @param feature
-     */
-    public RenderKitExtensionTranslator(String domNameAndPath,
-            EStructuralFeature feature) {
-        super(domNameAndPath, feature);
-    }
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RenderKitFactoryTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RenderKitFactoryTranslator.java
deleted file mode 100644
index 478e8b3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RenderKitFactoryTranslator.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang, itrimble
- *
- */
-public class RenderKitFactoryTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public RenderKitFactoryTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getRenderKitFactoryType_TextContent()),
-			new Translator("id", facesPackage.getRenderKitFactoryType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RenderKitIdTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RenderKitIdTranslator.java
deleted file mode 100644
index 80132e5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RenderKitIdTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for the renderkit id
- *
- */
-public class RenderKitIdTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public RenderKitIdTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getRenderKitIdType_TextContent()),
-			new Translator("id", facesPackage.getRenderKitIdType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RenderKitTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RenderKitTranslator.java
deleted file mode 100644
index 9c182d3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RenderKitTranslator.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - fixed getChildren()
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class RenderKitTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public RenderKitTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-				new DescriptionTranslator("description", facesPackage.getRenderKitType_Description()), //$NON-NLS-1$
-				new DisplayNameTranslator("display-name", facesPackage.getRenderKitType_DisplayName()), //$NON-NLS-1$
-				new IconTranslator("icon", facesPackage.getRenderKitType_Icon()), //$NON-NLS-1$
-				new RenderKitIdTranslator("render-kit-id", facesPackage.getRenderKitType_RenderKitId()), //$NON-NLS-1$
-				new RenderKitClassTranslator("render-kit-class", facesPackage.getRenderKitType_RenderKitClass()), //$NON-NLS-1$
-				new RendererTranslator("renderer", facesPackage.getRenderKitType_Renderer()), //$NON-NLS-1$
-				new ClientBehaviorRendererTranslator("client-behavior-renderer", facesPackage.getRenderKitType_ClientBehaviorRenderer()), //$NON-NLS-1$
-                new RenderKitExtensionTranslator("render-kit-extension", facesPackage.getRenderKitType_RenderKitExtension()), //$NON-NLS-1$
-				new Translator("id", facesPackage.getRenderKitType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RendererClassTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RendererClassTranslator.java
deleted file mode 100644
index c870bb1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RendererClassTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for renderer class
- *
- */
-public class RendererClassTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public RendererClassTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getRendererClassType_TextContent()),
-			new Translator("id", facesPackage.getRendererClassType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RendererExtensionTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RendererExtensionTranslator.java
deleted file mode 100644
index 24d900f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RendererExtensionTranslator.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - fixed getChildren()
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-/**
- * @author xnjiang, itrimble
- *
- */
-public class RendererExtensionTranslator extends ExtensionTypeTranslator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public RendererExtensionTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RendererTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RendererTranslator.java
deleted file mode 100644
index 9175d48..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RendererTranslator.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - fixed getChildren()
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class RendererTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public RendererTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-				new DescriptionTranslator("description", facesPackage.getRendererType_Description()), //$NON-NLS-1$
-				new DisplayNameTranslator("display-name", facesPackage.getRendererType_DisplayName()), //$NON-NLS-1$
-				new IconTranslator("icon", facesPackage.getRendererType_Icon()), //$NON-NLS-1$
-				new ComponentFamilyTranslator("component-family", facesPackage.getRendererType_ComponentFamily()), //$NON-NLS-1$
-				new RendererTypeTranslator("renderer-type", facesPackage.getRendererType_RendererType()), //$NON-NLS-1$
-				new RendererClassTranslator("renderer-class", facesPackage.getRendererType_RendererClass()), //$NON-NLS-1$
-				new FacetTranslator("facet", facesPackage.getRendererType_Facet()), //$NON-NLS-1$
-				new AttributeTranslator("attribute", facesPackage.getRendererType_Attribute()), //$NON-NLS-1$
-				new RendererExtensionTranslator("renderer-extension", facesPackage.getRendererType_RendererExtension()), //$NON-NLS-1$
-				new Translator("id", facesPackage.getRendererType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RendererTypeTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RendererTypeTranslator.java
deleted file mode 100644
index c2a0880..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/RendererTypeTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for the renderer type
- *
- */
-public class RendererTypeTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public RendererTypeTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getRendererTypeType_TextContent()),
-			new Translator("id", facesPackage.getRendererTypeType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ResourceBundleTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ResourceBundleTranslator.java
deleted file mode 100644
index 39b3937..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ResourceBundleTranslator.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for resource bundle element 
- *
- */
-public class ResourceBundleTranslator extends Translator {
-
-    /**
-     * @param domNameAndPath
-     * @param feature
-     */
-    public ResourceBundleTranslator(String domNameAndPath,
-            EStructuralFeature feature) {
-        super(domNameAndPath, feature);
-    }
-
-    protected Translator[] getChildren() {
-        
-        FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-        return new Translator[] {
-            new DescriptionTranslator("description", facesPackage.getResourceBundleType_Description()), //$NON-NLS-1$
-            new DisplayNameTranslator("display-name", facesPackage.getResourceBundleType_DisplayName()), //$NON-NLS-1$
-            new IconTranslator("icon", facesPackage.getResourceBundleType_Icon()), //$NON-NLS-1$
-            new BaseNameTranslator("base-name", facesPackage.getResourceBundleType_BaseName()), //$NON-NLS-1$
-            new VarTranslator("var", facesPackage.getResourceBundleType_Var()), //$NON-NLS-1$
-            new Translator("id", facesPackage.getResourceBundleType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-        };
-    }
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ResourceHandlerTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ResourceHandlerTranslator.java
deleted file mode 100644
index a6db8cb..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ResourceHandlerTranslator.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class ResourceHandlerTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ResourceHandlerTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/*  (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getResourceHandlerType_TextContent()),
-			new Translator("id", facesPackage.getResourceHandlerType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SkipUnknownChildrenTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SkipUnknownChildrenTranslator.java
deleted file mode 100644
index 79c4b6e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SkipUnknownChildrenTranslator.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * SkipUnknownChildrenTranslator has been implemented to temporarily allow
- * processing of application configuration resource files containing extension
- * elements (those defined with a content type of "ANY"); it essentially skips
- * all processing of child elements for which no child Translator has been
- * defined. This is not intended as a long-term solution.
- * 
- * @author Ian Trimble - Oracle
- */
-public class SkipUnknownChildrenTranslator extends Translator {
-
-	/**
-	 * Creates an instance.
-	 * 
-	 * @param domNameAndPath DOM name and path for which this Translator is
-	 * to be used.
-	 * @param aFeature EStructuralFeature instance for which this Translator is
-	 * to be used (may be null).
-	 */
-	public SkipUnknownChildrenTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#findChild(java.lang.String, java.lang.Object, int)
-	 */
-	public Translator findChild(String tagName, Object target, int versionID) {
-		Translator childTranslator = super.findChild(tagName, target, versionID);
-		if (childTranslator == null) {
-			childTranslator = new SkipUnknownChildrenTranslator(tagName, (EStructuralFeature)null);
-		}
-		return childTranslator;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SmallIconTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SmallIconTranslator.java
deleted file mode 100644
index f0d1859..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SmallIconTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for the small icon property
- *
- */
-public class SmallIconTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public SmallIconTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getSmallIconType_TextContent()),
-			new Translator("id", facesPackage.getSmallIconType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SourceClassTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SourceClassTranslator.java
deleted file mode 100644
index 62ca65b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SourceClassTranslator.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class SourceClassTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public SourceClassTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/*  (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getSourceClassType_TextContent()),
-			new Translator("id", facesPackage.getSourceClassType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/StateManagerTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/StateManagerTranslator.java
deleted file mode 100644
index 01bd027..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/StateManagerTranslator.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class StateManagerTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public StateManagerTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getStateManagerType_TextContent()),
-			new Translator("id", facesPackage.getStateManagerType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SuggestedValueTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SuggestedValueTranslator.java
deleted file mode 100644
index ffa16fa..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SuggestedValueTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for the suggested value property
- *
- */
-public class SuggestedValueTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public SuggestedValueTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getSuggestedValueType_TextContent()),
-			new Translator("id", facesPackage.getSuggestedValueType_Id(), DOM_ATTRIBUTE)//$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SupportedLocaleTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SupportedLocaleTranslator.java
deleted file mode 100644
index 5d4183c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SupportedLocaleTranslator.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang, itrimble
- *
- */
-public class SupportedLocaleTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public SupportedLocaleTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getSupportedLocaleType_TextContent()),
-			new Translator("id", facesPackage.getSupportedLocaleType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SystemEventClassTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SystemEventClassTranslator.java
deleted file mode 100644
index ada4185..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SystemEventClassTranslator.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class SystemEventClassTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public SystemEventClassTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/*  (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getSystemEventClassType_TextContent()),
-			new Translator("id", facesPackage.getSystemEventClassType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SystemEventListenerClassTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SystemEventListenerClassTranslator.java
deleted file mode 100644
index 055ca64..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SystemEventListenerClassTranslator.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class SystemEventListenerClassTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public SystemEventListenerClassTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/*  (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getSystemEventListenerClassType_TextContent()),
-			new Translator("id", facesPackage.getSystemEventListenerClassType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SystemEventListenerTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SystemEventListenerTranslator.java
deleted file mode 100644
index bf25c60..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/SystemEventListenerTranslator.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class SystemEventListenerTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public SystemEventListenerTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/*  (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new SystemEventListenerClassTranslator("system-event-listener-class", facesPackage.getSystemEventListenerType_SystemEventListenerClass()), //$NON-NLS-1$
-			new SystemEventClassTranslator("system-event-class", facesPackage.getSystemEventListenerType_SystemEventClass()), //$NON-NLS-1$
-			new SourceClassTranslator("source-class", facesPackage.getSystemEventListenerType_SourceClass()), //$NON-NLS-1$
-			new Translator("id", facesPackage.getSystemEventListenerType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/TagHandlerDelegateFactoryTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/TagHandlerDelegateFactoryTranslator.java
deleted file mode 100644
index 1d55b43..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/TagHandlerDelegateFactoryTranslator.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class TagHandlerDelegateFactoryTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public TagHandlerDelegateFactoryTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/*  (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getTagHandlerDelegateFactoryType_TextContent()),
-			new Translator("id", facesPackage.getTagHandlerDelegateFactoryType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ToViewIdTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ToViewIdTranslator.java
deleted file mode 100644
index 2eb3084..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ToViewIdTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for the toviewid property
- *
- */
-public class ToViewIdTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ToViewIdTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getToViewIdType_TextContent()),
-			new Translator("id", facesPackage.getToViewIdType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ValidatorClassTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ValidatorClassTranslator.java
deleted file mode 100644
index 5c74f34..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ValidatorClassTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for the validator class property
- *
- */
-public class ValidatorClassTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ValidatorClassTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getValidatorClassType_TextContent()),
-			new Translator("id", facesPackage.getValidatorClassType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ValidatorExtensionTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ValidatorExtensionTranslator.java
deleted file mode 100644
index 7e668e1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ValidatorExtensionTranslator.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-
-/**
- * Translator for the validator extension
- *
- */
-public class ValidatorExtensionTranslator extends ExtensionTypeTranslator 
-{
-    /**
-     * @param domNameAndPath
-     * @param feature
-     */
-    public ValidatorExtensionTranslator(String domNameAndPath,
-            EStructuralFeature feature) {
-        super(domNameAndPath, feature);
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ValidatorIdTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ValidatorIdTranslator.java
deleted file mode 100644
index 34a07fd..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ValidatorIdTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for the validator id
- *
- */
-public class ValidatorIdTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ValidatorIdTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getValidatorIdType_TextContent()),
-			new Translator("id", facesPackage.getValidatorIdType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ValidatorTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ValidatorTranslator.java
deleted file mode 100644
index 13ec22e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ValidatorTranslator.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - fixed getChildren()
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class ValidatorTranslator extends Translator {
-	
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ValidatorTranslator(String domNameAndPath,EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature);
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new DescriptionTranslator("description", facesPackage.getValidatorType_Description()), //$NON-NLS-1$
-			new DisplayNameTranslator("display-name", facesPackage.getValidatorType_DisplayName()), //$NON-NLS-1$
-			new IconTranslator("icon", facesPackage.getValidatorType_Icon()), //$NON-NLS-1$
-			new ValidatorIdTranslator("validator-id", facesPackage.getValidatorType_ValidatorId()), //$NON-NLS-1$
-			new ValidatorClassTranslator("validator-class", facesPackage.getValidatorType_ValidatorClass()), //$NON-NLS-1$
-			new AttributeTranslator("attribute", facesPackage.getValidatorType_Attribute()), //$NON-NLS-1$
-			new PropertyTranslator("property", facesPackage.getValidatorType_Property()), //$NON-NLS-1$
-            new ValidatorExtensionTranslator("validator-extension", facesPackage.getValidatorType_ValidatorExtension()), //$NON-NLS-1$
-			new Translator("id", facesPackage.getValidatorType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ValueClassTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ValueClassTranslator.java
deleted file mode 100644
index 9bed430..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ValueClassTranslator.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Ian Trimble - initial API and implementation
- *******************************************************************************/ 
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for the value class
- *
- */
-public class ValueClassTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ValueClassTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getValueClassType_TextContent()),
-			new Translator("id", facesPackage.getValueClassType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ValueTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ValueTranslator.java
deleted file mode 100644
index dfca7ce..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ValueTranslator.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added is attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang, itrimble
- *
- */
-public class ValueTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ValueTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getValueType_TextContent()),
-			new Translator("id", facesPackage.getValueType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/VarTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/VarTranslator.java
deleted file mode 100644
index 0062415..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/VarTranslator.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * Translator for the var
- *
- */
-public class VarTranslator extends Translator {
-    /**
-     * @param domNameAndPath
-     * @param feature
-     */
-    public VarTranslator(String domNameAndPath, EStructuralFeature feature) {
-        super(domNameAndPath, feature, END_TAG_NO_INDENT);
-    }
-
-    public Translator[] getChildren()
-    {
-        FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-
-        return new Translator[] {
-            new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getVarType_TextContent()),
-            new Translator("id", facesPackage.getVarType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-        };
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/VariableResolverTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/VariableResolverTranslator.java
deleted file mode 100644
index 96c1eef..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/VariableResolverTranslator.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class VariableResolverTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public VariableResolverTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getVariableResolverType_TextContent()),
-			new Translator("id", facesPackage.getVariableResolverType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ViewDeclarationLanguageFactoryTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ViewDeclarationLanguageFactoryTranslator.java
deleted file mode 100644
index c6558dc..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ViewDeclarationLanguageFactoryTranslator.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class ViewDeclarationLanguageFactoryTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ViewDeclarationLanguageFactoryTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/*  (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getViewDeclarationLanguageFactoryType_TextContent()),
-			new Translator("id", facesPackage.getViewDeclarationLanguageFactoryType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ViewHandlerTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ViewHandlerTranslator.java
deleted file mode 100644
index 655c548..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/ViewHandlerTranslator.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - added id attribute
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xjiang, itrimble
- *
- */
-public class ViewHandlerTranslator extends Translator {
-
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public ViewHandlerTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getViewHandlerType_TextContent()),
-			new Translator("id", facesPackage.getViewHandlerType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/VisitContextFactoryTranslator.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/VisitContextFactoryTranslator.java
deleted file mode 100644
index e3fb8ce..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/internal/translator/VisitContextFactoryTranslator.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.internal.translator;
-
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigPackage;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-
-/**
- * @author xnjiang
- *
- */
-public class VisitContextFactoryTranslator extends Translator {
-	/**
-	 * @param domNameAndPath
-	 * @param aFeature
-	 */
-	public VisitContextFactoryTranslator(String domNameAndPath, EStructuralFeature aFeature) {
-		super(domNameAndPath, aFeature, END_TAG_NO_INDENT);
-	}
-
-	/*  (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.Translator#getChildren()
-	 */
-	public Translator[] getChildren() {
-		
-		FacesConfigPackage facesPackage = FacesConfigPackage.eINSTANCE;
-		return new Translator[] {
-			new Translator(TEXT_ATTRIBUTE_VALUE, facesPackage.getVisitContextFactoryType_TextContent()),
-			new Translator("id", facesPackage.getVisitContextFactoryType_Id(), DOM_ATTRIBUTE) //$NON-NLS-1$
-		};
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/package-info.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/package-info.java
deleted file mode 100644
index f5d82ab..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/package-info.java
+++ /dev/null
@@ -1,16 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Oracle - initial API and implementation
- *    
- ********************************************************************************/
-
-/**
- * Not considered an API package and will be made internal in the MANIFEST in some future release
- */
-package org.eclipse.jst.jsf.facesconfig;
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesConfigArtifactEdit.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesConfigArtifactEdit.java
deleted file mode 100644
index 9cafba1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesConfigArtifactEdit.java
+++ /dev/null
@@ -1,259 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.util;
-
-import java.util.List;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IProject;
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType;
-import org.eclipse.wst.common.componentcore.ArtifactEdit;
-import org.eclipse.wst.common.componentcore.internal.ArtifactEditModel;
-import org.eclipse.wst.common.componentcore.resources.IVirtualFile;
-import org.eclipse.wst.common.componentcore.resources.IVirtualResource;
-import org.eclipse.wst.xml.core.internal.emf2xml.EMF2DOMSSERenderer;
-import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;
-
-
-/**
- * The artifact edit for the JSF Application Configuration (faces-config) model - may be used but not extended by clients.
- * 
- * This class maybe refactored to a different package in the future.
- */
-public final class FacesConfigArtifactEdit extends ArtifactEdit {
-
-	private static final String EDIT_MODEL_ID = "jsf.facesconfig"; //$NON-NLS-1$
-
-	private String sFileName = null;
-	private FacesConfigType facesConfig = null;
-	private URI facesConfigURI = URI.createURI(IFacesConfigConstants.FACES_CONFIG_URI);
-	private boolean bRegistered = false;
-
-	/**
-	 * @param aProject
-	 * @param toAccessAsReadOnly
-	 * @throws IllegalArgumentException
-	 */
-	public FacesConfigArtifactEdit(IProject aProject, boolean toAccessAsReadOnly) throws IllegalArgumentException {
-		super(aProject, toAccessAsReadOnly, false, EDIT_MODEL_ID);
-	}
-
-	/**
-	 * @param aProject
-	 * @param sConfigFile
-	 * @return the faces config artifact for the file config file sConfig in project aProject.
-	 * Opened only for read access (no write)
-	 */
-	public static FacesConfigArtifactEdit getFacesConfigArtifactEditForRead(IProject aProject, String sConfigFile) {
-		FacesConfigArtifactEdit artifactEdit = null;
-		try {
-			artifactEdit = new FacesConfigArtifactEdit(aProject, true);
-			if (artifactEdit != null) {
-				artifactEdit.setFilename(sConfigFile);
-			}
-		} catch (IllegalArgumentException iae) {
-            // suppress illegal argument exception
-            FacesConfigPlugin.write(iae);
-		}
-		return artifactEdit;
-	}
-	/**
-	 * @param aProject
-	 * @return the default artifact edit
-     * @deprecated Use getFacesConfigArtifactEditForRead(IProject, String) instead. This
-     * method is dangerous because the caller is assuming that the "default"
-     * model exists and knows nothing about where it is coming from.
-	 */
-	public static FacesConfigArtifactEdit getFacesConfigArtifactEditForRead(IProject aProject) {
-		return getFacesConfigArtifactEditForRead(aProject, null);
-	}
-
-    /**
-     * @param aProject
-     * @param sConfigFile
-     * @return the faces config artifact for the file config file sConfig in project aProject.
-     * Opened for both write and read access
-     */	
-	public static FacesConfigArtifactEdit getFacesConfigArtifactEditForWrite(IProject aProject, String sConfigFile) {
-		FacesConfigArtifactEdit artifactEdit = null;
-		try {
-			artifactEdit = new FacesConfigArtifactEdit(aProject, false);
-			if (artifactEdit != null) {
-				artifactEdit.setFilename(sConfigFile);
-			}
-		} catch (IllegalArgumentException iae) {
-            // suppress illegal argument exception
-            FacesConfigPlugin.write(iae);
-		}
-		return artifactEdit;
-	}
-
-	/**
-	 * @param aProject
-	 * @return the default artifact edit for read
-     * @deprecated Use getFacesConfigArtifactEditForWrite(IProject, String) 
-     * instead. This method is dangerous because the caller is assuming that
-     * the "default" model exists and knows nothing about where it is coming
-     * from.
-	 */
-	public static FacesConfigArtifactEdit getFacesConfigArtifactEditForWrite(IProject aProject) {
-		return getFacesConfigArtifactEditForWrite(aProject, null);
-	}
-
-	/**
-	 * @return the root model object for this artifact edit model
-	 */
-	public FacesConfigType getFacesConfig() {
-		if (facesConfig == null) {
-			// TODO: XN - does not seem a good way to check whether the resource has been registered each time.
-			// The following comment is from StrutsArchfactEdit:
-			// This is a hack to ensure that our Resource.Factory is used to
-			// create
-			// the Resource. It's the same hack used by JaxRPCMapArtifactEdit.
-			// The problem is that there is no way to register a Resource.Factory
-			// by, say, content type.
-			// The best we can do is register by last file segment, which isn't
-			// strictly correct.
-			// Plus, there's no way to deregister.
-			if (sFileName != null) {
-				if (!bRegistered) {
-				//if (FacesConfigResourceFactory.getRegisteredFactory(URI.createURI(sFileName)) == null) {
-					FacesConfigResourceFactory.register(sFileName);
-					bRegistered = true;
-				}
-			}
-			facesConfig = (FacesConfigType)getDeploymentDescriptorRoot(); 
-		}
-		return facesConfig;
-	}
-	
-	/**
-	 * @return the uri pointing to the source of this faces config artifact
-	 */
-	public URI getFacesConfigURI() {
-		return facesConfigURI;
-	}
-
-    /**
-     * @return the model root
-     */
-    public EObject getDeploymentDescriptorRoot()
-    {
-        Resource deploymentDescriptorResource = getDeploymentDescriptorResource();
-        if (deploymentDescriptorResource != null)
-        {
-            List contents = deploymentDescriptorResource.getContents();
-            if (contents.size() > 0)
-            {
-                return (EObject) contents.get(0);
-            }
-        }
-        return null;
-        // TODO: XN
-        // addFacesConfigIfNecessary((IFacesConfigResource)getDeploymentDescriptorResource());
-        // return (EObject) contents.get(0);
-    }
-
-	/**
-	 * @return the EMF resource retrieved for this artifact's uri or null if
-	 * this descriptor has not resource.
-	 */
-	public Resource getDeploymentDescriptorResource() {
-		if (sFileName != null) {
-			facesConfigURI = URI.createURI(sFileName);
-		} else {// default is "WEB-INF/faces-config.xml"
-			facesConfigURI = URI.createURI(IFacesConfigConstants.FACES_CONFIG_URI);
-		}
-		final ArtifactEditModel artifactEditModel = getArtifactEditModel();
-		if (artifactEditModel != null)
-		{
-		    return artifactEditModel.getResource(facesConfigURI);
-		}
-		return null;
-	}
-
-	/**
-	 * Sets an instance's filename, used to create a URI and load a model.
-	 * 
-	 * @param filename This instance's filename.
-	 */
-	public void setFilename(String filename) {
-		sFileName = filename;
-		if (filename != null && filename.length() > 0) {
-			facesConfigURI = URI.createURI(filename);
-		}
-	}
-
-	// TODO: appears to be dead
-//	protected void addFacesConfigIfNecessary(TranslatorResource aResource) {
-//		//TO: XN - See how to create one if the config file does not exist
-//		/*if (aResource != null) {
-//		    if(aResource.getContents() == null || aResource.getContents().isEmpty()) {
-//		        FacesConfigType facesConfigNew = WebapplicationFactory.eINSTANCE.createWebApp();
-//				aResource.getContents().add(facesConfigNew);
-//				aResource.setModified(true);
-//		    } 
-//		    FacesConfigType facesConfig = (FacesConfigType)aResource.getContents().get(0);
-//			URI moduleURI = getArtifactEditModel().getModuleURI();
-//			try {
-//				facesConfig.setDisplayName(StructureEdit.getDeployedName(moduleURI));
-//			} catch (UnresolveableURIException e) {
-//				//Ignore
-//			}
-//			aResource.setID(facesConfig, J2EEConstants.WEBAPP_ID);
-//	
-//			try{
-//				aResource.saveIfNecessary();
-//			}catch(Exception e){
-//				e.printStackTrace();
-//			}
-//		}*/
-//	}
-
-	/**
-	 * @return the DOM model for the Struts config. file.
-	 */
-	public IDOMModel getIDOMModel() {
-		// Modeled after SourceNestedEditorPage.getXMLModelFromResource().
-		// TODO - XN This is a little hackish because it depends on the resource's
-		// renderer being an EMF2DOMSedRenderer (which it is, but that could
-		// change).
-		Resource resource = getDeploymentDescriptorResource();
-		if (resource instanceof IFacesConfigResource) {
-			EMF2DOMSSERenderer renderer = (EMF2DOMSSERenderer) 
-			    ((IFacesConfigResource)resource).getRenderer();
-			return renderer.getXMLModel();
-		}
-		return null;
-	}
-
-	/**
-	 * @return the IFile used to load the model or null if none.
-	 */
-	public IFile getFile() {
-		IVirtualResource resource = getComponent().getRootFolder().findMember(facesConfigURI.toString());
-		if ((resource != null) && (resource.getType() == IVirtualResource.FILE))
-			return ((IVirtualFile) resource).getUnderlyingFile();
-		return null;
-	}
-    
-    /**
-     * @return true if the underlying model has been disposed
-     */
-    public boolean isDisposed()
-    {
-        return getArtifactEditModel().isDisposed();
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesConfigChangeEvent.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesConfigChangeEvent.java
deleted file mode 100644
index ecbc42e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesConfigChangeEvent.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.util;
-
-/**
- * This class should NOT be referenced or extended by clients.
- * 
- * @author xnjiang
- *
- */
-final class FacesConfigChangeEvent implements IFacesConfigChangeEvent {
-
-	private boolean bManagedBeandChanged = true;
-	private boolean bNavigationRuleChanged = true;
-	
-	/* (non-Javadoc)
-	 * @see org.eclipse.jst.jsf.facesconfig.IFacesConfigChangeEvent#isManagedBeanChanged()
-	 */
-	public boolean isManagedBeanChanged() {
-		return bManagedBeandChanged;
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.jst.jsf.facesconfig.IFacesConfigChangeEvent#isNavigationRuleChanged()
-	 */
-	public boolean isNavigationRuleChanged() {
-		return bNavigationRuleChanged;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesConfigResourceFactory.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesConfigResourceFactory.java
deleted file mode 100644
index d8ba4c9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesConfigResourceFactory.java
+++ /dev/null
@@ -1,91 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.util;
-
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.wst.common.componentcore.internal.impl.WTPResourceFactoryRegistry;
-import org.eclipse.wst.common.internal.emf.resource.EMF2DOMRendererFactory;
-import org.eclipse.wst.common.internal.emf.resource.Renderer;
-import org.eclipse.wst.common.internal.emf.resource.RendererFactory;
-import org.eclipse.wst.common.internal.emf.resource.TranslatorResource;
-import org.eclipse.wst.common.internal.emf.resource.TranslatorResourceFactory;
-
-/**
- * May be referenced but should NOT be extended by clients
- * 
- * @author xjiang
- *
- */
-public final class FacesConfigResourceFactory extends TranslatorResourceFactory 
-{
-    /**
-     * @return a faces config resource factory for use with faces-config
-     * files contained in JARs
-     */
-    public static FacesConfigResourceFactory createResourceFactoryForJar()
-    {
-        return new FacesConfigResourceFactory(EMF2DOMRendererFactory.INSTANCE);
-    }
-    
-	/**
-	 * Construct a faces resource factory.
-	 * 
-	 * @param rendererFactory 
-	 */
-	protected FacesConfigResourceFactory(RendererFactory rendererFactory) {
-		super(rendererFactory);
-	}
-
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.TranslatorResourceFactory#createResource(org.eclipse.emf.common.util.URI)
-	 */
-	protected TranslatorResource createResource(URI uri, Renderer aRenderer) {
-		return new FacesConfigResourceImpl(uri, aRenderer);
-	}
-	
-	/**
-	 * Method registerDtds.
-	 */
-	public static void registerDtds() {
-	    // TODO: should we be registering dtd/xsd here?
-	    // how does MyEntityResolver in the resource affect this (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=154439)
-	}
-
-	/**
-	 * register using the default renderer factory.
-	 * @see #registerWith(String, FacesRendererFactory)
-	 */
-	public static void register() {
-		register((String)null);
-	}
-
-	/**
-	 * Register the sFileName with the default renderer factory
-	 * @param sFileName
-	 */
-	public static void register(String sFileName) {
-		registerWith(sFileName, FacesRendererFactory.INSTANCE);
-	}
-
-	/**
-	 * Register myself with the Resource.Factory.Registry
-	 * @param sFileName 
-	 * @param aRendererFactory 
-	 */
-	private static void registerWith(String sFileName, FacesRendererFactory aRendererFactory) {
-		if (sFileName != null) {
-			WTPResourceFactoryRegistry.INSTANCE.registerLastFileSegment(sFileName, new FacesConfigResourceFactory(FacesRendererFactory.INSTANCE));
-		} else {
-			WTPResourceFactoryRegistry.INSTANCE.registerLastFileSegment("faces-config.xml", new FacesConfigResourceFactory(FacesRendererFactory.INSTANCE)); //$NON-NLS-1$
-		}
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesConfigResourceImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesConfigResourceImpl.java
deleted file mode 100644
index 2fc096b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesConfigResourceImpl.java
+++ /dev/null
@@ -1,133 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.util;
-
-import java.io.IOException;
-
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType;
-import org.eclipse.jst.jsf.facesconfig.internal.translator.FacesConfigTranslator;
-import org.eclipse.wst.common.internal.emf.resource.Renderer;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-import org.eclipse.wst.common.internal.emf.resource.TranslatorResourceImpl;
-import org.eclipse.wst.common.uriresolver.internal.provisional.URIResolver;
-import org.eclipse.wst.common.uriresolver.internal.provisional.URIResolverPlugin;
-import org.xml.sax.EntityResolver;
-import org.xml.sax.InputSource;
-import org.xml.sax.SAXException;
-
-
-/**
- * <!-- begin-user-doc -->
- * The <b>Resource </b> associated with the package - NOT intended for external use.
- * Should not be used or implemented by external clients
- * 
- * <!-- end-user-doc -->
- * @see FacesConfigResourceFactory
- * @generated
- */
-public class FacesConfigResourceImpl extends TranslatorResourceImpl implements IFacesConfigResource {
-
-	/**
-	 * Local entity resolver used to help loading entities - NOT intended for external use.
-	 * Should not be used or implemented by external clients
-	 */
-	public static class MyEntityResolver implements EntityResolver {
-
-		private final String baseLocation;
-		private URIResolver uriResolver = null;
-		
-		/**
-		 * @param baseLocation
-		 */
-		public MyEntityResolver(String baseLocation) {
-			super();
-			this.baseLocation = baseLocation;
-		}
-
-		public InputSource resolveEntity(String publicId, String systemId)
-				throws SAXException, IOException {
-			if (uriResolver == null) {
-				uriResolver = URIResolverPlugin.createResolver();
-			}
-			String logicalLocation = uriResolver.resolve(baseLocation, publicId, systemId);
-			String physicalLocation= uriResolver.resolvePhysicalLocation(baseLocation, publicId, logicalLocation);
-			return new InputSource(physicalLocation);		
-		}
-
-	}
-	
-	private EntityResolver entityResolver = null;
-	
-	/**
-	 * @param aRenderer
-	 */
-	public FacesConfigResourceImpl(Renderer aRenderer) {
-		super(aRenderer);
-	}
-	/**
-	 * @param uri
-	 * @param aRenderer
-	 */
-	public FacesConfigResourceImpl(URI uri, Renderer aRenderer) {
-		super(uri, aRenderer);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.TranslatorResource#getDoctype()
-	 */
-	public String getDoctype() {
-		return null;
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.TranslatorResource#getRootTranslator()
-	 */
-	public Translator getRootTranslator() {
-		return FacesConfigTranslator.INSTANCE; 
-
-	}
-    /* (non-Javadoc)
-     * @see org.eclipse.jst.jsf.emf.facesconfig.xml.FacesConfigResource#getFacesConfig()
-     */
-    public FacesConfigType getFacesConfig() {
-		return (FacesConfigType) getRootObject();
-    }
-    
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.TranslatorResourceImpl#getDefaultPublicId()
-	 */
-	protected String getDefaultPublicId() {
-		return "-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.0//EN"; //$NON-NLS-1$
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.TranslatorResourceImpl#getDefaultSystemId()
-	 */
-	protected String getDefaultSystemId() {
-		return "http://java.sun.com/dtd/web-facesconfig_1_0.dtd"; //$NON-NLS-1$
-	}
-	/* (non-Javadoc)
-	 * @see org.eclipse.wst.common.internal.emf.resource.TranslatorResourceImpl#getDefaultVersionID()
-	 */
-	protected int getDefaultVersionID() {
-		return 0;
-	}
-	public EntityResolver getEntityResolver() {
-		if (entityResolver == null) {
-			String baseLocation = getURI().toString();
-			entityResolver = new MyEntityResolver(baseLocation);
-		}
-		return entityResolver;
-	}
-	public void setURI(URI arg0) {
-		super.setURI(arg0);
-		entityResolver = null;
-	}
-} //FacesConfigResourceFactoryImpl
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesConfigRestartServerResourceDeltaVisitor.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesConfigRestartServerResourceDeltaVisitor.java
deleted file mode 100644
index 73d46bb..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesConfigRestartServerResourceDeltaVisitor.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.util;
-
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Set;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.resources.IResourceDelta;
-import org.eclipse.core.resources.IResourceDeltaVisitor;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.wst.common.componentcore.internal.util.ComponentUtilities;
-import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
-
-/**
- * This class is NOT intended for external use.
- * 
- * @version $Id$
- */
-final class FacesConfigRestartServerResourceDeltaVisitor implements IResourceDeltaVisitor {
-
-	/** Set of IProjects. */
-	private Set components = new HashSet();
-
-	/**
-	 * @see org.eclipse.core.resources.IResourceDeltaVisitor#visit(org.eclipse.core.resources.IResourceDelta)
-	 */
-	public boolean visit(IResourceDelta delta) throws CoreException {
-
-		if (shouldCheckForRestartProject()) {
-			int kind = delta.getKind();
-			if ((kind == IResourceDelta.ADDED)
-					|| (kind == IResourceDelta.REMOVED)
-					|| ((kind == IResourceDelta.CHANGED) && ((delta.getFlags() & (IResourceDelta.CONTENT
-							| IResourceDelta.TYPE | IResourceDelta.SYNC | IResourceDelta.REPLACED)) != 0))) {
-				primCheckForRestartComponent(delta.getResource());
-			}
-		}
-
-		// Done.
-		return true;
-	}
-
-	private boolean shouldCheckForRestartProject() {
-		//TODO: XN: we don't have preference page for this?
-		//return FacesconfigPlugin.getPlugin().getFacesPreferences().getRestart();
-		return true;
-	}
-
-	private void primCheckForRestartComponent(IResource resource) {
-		if (resource.getType() == IResource.FILE) {
-			IFile file = (IFile) resource;
-			if (FacesConfigUtil.isFacesConfigFile(file)) {
-				IVirtualComponent component = ComponentUtilities.findComponent(file);
-				if (component != null) {
-					components.add(component);
-				}
-			}
-				
-		}
-	}
-
-	/**
-	 * @return the components
-	 */
-	public Collection getComponents() {
-		return components;
-	}
-}
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesConfigUtil.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesConfigUtil.java
deleted file mode 100644
index 515ec06..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesConfigUtil.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.util;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.content.IContentDescription;
-import org.eclipse.core.runtime.content.IContentType;
-
-/**
- * Utility class for faces-config model management
- * 
- * This class is NOT intended for external use.
- * 
- */
-final class FacesConfigUtil {
-
-	/** Must match the id specified in plugin.xml. */
-	public static final String FACES_CONFIG_CONTENT_TYPE_ID = "org.eclipse.jst.jsf.facesconfig.facesConfigFile"; //$NON-NLS-1$
-
-	/**
-	 * Returns true iff the specified file seems to be a Faces configuration
-	 * file. Always returns false if the file is in a non-Faces project.
-	 * 
-	 * @param file
-	 *            the IFile to check
-	 * @return true iff the specified file seems to be a Faces configuration
-	 *         file.
-	 */
-	public static boolean isFacesConfigFile(IFile file) {
-		return isFacesConfigFile(file, true);
-	}
-
-	/**
-	 * Returns true iff the specified file seems to be a Faces configuration
-	 * file. If ignoreNonFacesProject is true, always returns false if the file
-	 * is in a non-Faces project.
-	 * 
-	 * @param file
-	 *            the IFile to check
-	 * @param ignoreNonFacesProject
-	 * @return true iff the specified file seems to be a Faces configuration
-	 *         file.
-	 */
-	public static boolean isFacesConfigFile(IFile file, boolean ignoreNonFacesProject) {
-		
-		// Bail if it's not a .xml file.
-		if (!"xml".equalsIgnoreCase(file.getFileExtension())) //$NON-NLS-1$
-			return false;
-
-		// Bail if we can't determine the project. This shouldn't be possible
-		// here, but...
-		IProject project = file.getProject();
-		if (project == null)
-			return false;
-
-		// If requested, bail if the project isn't a Faces project.
-		// TODO: XN - temporarily disabled the following two lines to get rid 
-		// of the dependency on jsf.util
-		//if (ignoreNonFacesProject && !JsfProjectUtil.isJsfProject(project))
-			//return false;
-
-		try {
-			IContentDescription contentDescription = file.getContentDescription();
-			if (contentDescription != null) {
-				IContentType contentType = contentDescription.getContentType();
-				if (contentType != null)
-					return FACES_CONFIG_CONTENT_TYPE_ID.equals(contentType.getId());
-			}
-		} catch (CoreException ignored) {
-			// Empty block intended.
-		}
-
-		return false;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesRendererFactory.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesRendererFactory.java
deleted file mode 100644
index db93581..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesRendererFactory.java
+++ /dev/null
@@ -1,221 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2001, 2008 Oracle Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Oracle Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.util;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.jst.jsf.facesconfig.emf.DynamicElement;
-import org.eclipse.jst.jsf.facesconfig.internal.translator.IAnyTranslator;
-import org.eclipse.wst.common.internal.emf.resource.EMF2DOMAdapter;
-import org.eclipse.wst.common.internal.emf.resource.EMF2DOMRenderer;
-import org.eclipse.wst.common.internal.emf.resource.Renderer;
-import org.eclipse.wst.common.internal.emf.resource.Translator;
-import org.eclipse.wst.common.internal.emf.resource.TranslatorResource;
-import org.eclipse.wst.xml.core.internal.emf2xml.EMF2DOMSSEAdapter;
-import org.eclipse.wst.xml.core.internal.emf2xml.EMF2DOMSSERenderer;
-import org.eclipse.wst.xml.core.internal.emf2xml.EMF2DOMSSERendererFactory;
-import org.w3c.dom.Document;
-import org.w3c.dom.Element;
-import org.w3c.dom.Node;
-
-/**
- * This class should not be referenced or sub-classed externally.
- * 
- * The custom render factory for the Faces Config model EMF2DOM translations.
- * A singleton factory.
- */
-final class FacesRendererFactory extends EMF2DOMSSERendererFactory 
-{
-    /**
-     * The singleton factory instance.
-     */
-    @SuppressWarnings("hiding")
-    public static  FacesRendererFactory INSTANCE = new FacesRendererFactory();
-    
-    private FacesRendererFactory() {
-        super();
-    }
-
-    /**
-     * @see org.eclipse.wst.common.internal.emf.resource.RendererFactory#createRenderer()
-     */
-    public Renderer createRenderer() {
-        return new MyRenderer();
-    }
-
-    private static class MyRenderer extends EMF2DOMSSERenderer
-    {
-
-        protected EMF2DOMAdapter createRootDOMAdapter() 
-        {
-            return new MyEMF2DOMAdapterRoot(getResource(), document, this, getResource().getRootTranslator());
-        }
-    }
-    
-    /**
-     * Customized adapter that lets us inject arbitrary DOM children
-     * into for ANY elements
-     */
-    private static class MyEMF2DOMAdapterRoot extends EMF2DOMSSEAdapter
-    {
-
-        /**
-         * @param object
-         * @param node
-         * @param renderer
-         * @param translator
-         */
-        public MyEMF2DOMAdapterRoot(org.eclipse.emf.common.notify.Notifier object, Node node,
-                EMF2DOMRenderer renderer, Translator translator) {
-            super(object, node, renderer, translator);
-        }
-
-        /**
-         * @param node
-         * @param renderer
-         * @param translator
-         */
-        public MyEMF2DOMAdapterRoot(Node node, EMF2DOMRenderer renderer,
-                Translator translator) {
-            super(node, renderer, translator);
-        }
-
-        /**
-         * @param resource
-         * @param document
-         * @param renderer
-         * @param translator
-         */
-        public MyEMF2DOMAdapterRoot(TranslatorResource resource, Document document,
-                EMF2DOMRenderer renderer, Translator translator) {
-            super(resource, document, renderer, translator);
-        }
-
-        protected void initChildTranslators() {
-            // if this is an ANY translator, then we have prepend the list after
-            // initialization with any dynamic attribute translators
-            super.initChildTranslators();
-            
-            if (fTranslator instanceof IAnyTranslator)
-            {
-                final Translator[] dynamicAttrs =
-                    ((IAnyTranslator)fTranslator)
-                         .getDynamicAttributeTranslators(fNode);
-                
-                // avoid an array copy if not necessary
-                if (dynamicAttrs.length > 0)
-                {
-                    final Translator[] allTranslators =
-                        new Translator[childTranslators.length+dynamicAttrs.length];
-                    // prepend the dynamic attributes so they are queried first
-                    System.arraycopy(dynamicAttrs, 0, allTranslators, 0, dynamicAttrs.length);
-                    System.arraycopy(childTranslators, 0, allTranslators, dynamicAttrs.length, childTranslators.length);
-                    childTranslators = allTranslators;
-                }
-            }
-        }
-
-        protected Translator[] getChildTranslators() 
-        {
-            Translator[] translators = super.getChildTranslators();
-            // TODO: I'm thinking there must be a more efficient way to do this
-            if (fTranslator instanceof  IAnyTranslator)
-            {
-               EObject eObj = getEObject();
-               
-               if (eObj instanceof DynamicElement)
-               {
-                   List newArrayList = new ArrayList();
-                   Translator[] dynamicTranslators = 
-                       ((IAnyTranslator)fTranslator).getDynamicAttributeTranslators((DynamicElement)eObj);
-                   
-                   // loop through the dynamic translators and add any to the list
-                   // that aren't already there
-                   for (int i = 0; i < dynamicTranslators.length; i++)
-                   {
-                       Translator translator = dynamicTranslators[i];
-                       
-                       for (int j = 0; j < translators.length; j++)
-                       {
-                           final Translator testTranslator = translators[j];
-                           
-                           if (testTranslator.isDOMAttribute()
-                               // TODO: not fond of passing null, but the arg is ignored anyway (for now)
-                               && testTranslator.getDOMName(null).equals(translator.getDOMName(null)))
-                           {
-                               // null indicates found
-                               translator = null;
-                               break;
-                           }
-                        }
-                       
-                        // if not found, add to list
-                        if (translator != null)
-                        {
-                            newArrayList.add(translator);
-                        }
-                    }
-                   
-                    if (newArrayList.size() > 0)
-                    {
-                        newArrayList.addAll(Arrays.asList(translators));
-                        translators = (Translator[]) newArrayList.toArray(translators);
-                    }
-                }
-            }
-            
-            return translators;
-        }
-
-        protected List getDOMChildren(Node node, Translator map) 
-        {
-            if (map instanceof IAnyTranslator)
-            {
-                List children = new ArrayList();
-                
-                for (int i = 0; i < node.getChildNodes().getLength(); i++)
-                {
-                    Node child = node.getChildNodes().item(i);
-                    if (child.getNodeType() == Node.ELEMENT_NODE)
-                    {
-                        children.add(child);
-                    }
-                }
-                return children;
-            }
-            return super.getDOMChildren(node, map);
-        }
-        /**
-         * Create an adapter for a child DOM node
-         * 
-         * @param mofObject
-         *            org.w3c.dom.Node The node to create the adapter for.
-         */
-        protected EMF2DOMAdapter primCreateAdapter(EObject mofObject, Translator childMap) {
-            // TODO: this may only be necessary when childMap is an IAnyTranslator...
-            Element newNode = createNewNode(mofObject, childMap);
-            return new MyEMF2DOMAdapterRoot(mofObject, newNode, fRenderer, childMap);
-        }
-
-        /**
-         * Create an adapter for a child DOM node
-         * 
-         * @param node
-         *            org.w3c.dom.Node The node to create the adapter for.
-         */
-        protected EMF2DOMAdapter primCreateAdapter(Node node, Translator childMap) {
-            return new MyEMF2DOMAdapterRoot(node, fRenderer, childMap);
-        }
-    }
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesResourceChangeListener.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesResourceChangeListener.java
deleted file mode 100644
index c328f25..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/FacesResourceChangeListener.java
+++ /dev/null
@@ -1,361 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.util;
-
-import java.util.LinkedList;
-import java.util.ListIterator;
-
-import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.resources.IResourceChangeEvent;
-import org.eclipse.core.resources.IResourceChangeListener;
-import org.eclipse.core.resources.IResourceDelta;
-import org.eclipse.core.resources.IResourceDeltaVisitor;
-import org.eclipse.core.resources.IResourceVisitor;
-import org.eclipse.core.resources.ISaveContext;
-import org.eclipse.core.resources.ISaveParticipant;
-import org.eclipse.core.resources.ResourcesPlugin;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.QualifiedName;
-import org.eclipse.jface.preference.IPreferenceStore;
-import org.eclipse.jst.jsf.facesconfig.FacesConfigPlugin;
-import org.eclipse.jst.jsf.facesconfig.internal.Logger;
-import org.eclipse.ui.IEditorDescriptor;
-import org.eclipse.ui.IEditorRegistry;
-import org.eclipse.ui.PlatformUI;
-import org.eclipse.wst.common.componentcore.internal.util.ComponentUtilities;
-import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
-
-/**
- * This class is responsible for the following:
- * <ol>
- * <li>Ensure that the Struts nature is added to any project to which a Struts
- * config. file is added.</li>
- * <li>Ensure that the Struts nature is added to any project to which a diagram
- * file is added.</li>
- * <li>Restart project(s) if/as apporopriate when a Struts config. file is
- * modified.
- * </ol>
- * It arguably should be multiple classes, but the things it does are closely
- * related and splitting it up would result in duplicate work as well as
- * multiple delta traversals.
- * 
- * This class is not intended for external use. 
- * Should NOT be referenced or extended externally.
- */
-final class FacesResourceChangeListener implements IResourceChangeListener,
-		IResourceDeltaVisitor, ISaveParticipant, IResourceVisitor {
-
-	/** The singleton instance. */
-	private static FacesResourceChangeListener listener;
-	private static boolean restartInProgress = false;
-	private LinkedList facesConfigChangeListeners = new LinkedList();
-	
-	private static IPreferenceStore preferenceStore = null;
-
-	private static final QualifiedName EDITOR_KEY = new QualifiedName(
-			"org.eclipse.ui.internal.registry.ResourceEditorRegistry", "EditorProperty");//$NON-NLS-2$//$NON-NLS-1$
-
-	/** Start up the singleton instance. */
-	public static void startup() {
-
-		// Bail if we're already started.
-		if (listener != null)
-			return;
-
-		// Create the singleton instance.
-		listener = new FacesResourceChangeListener();
-
-		// Register as resource change listener.
-		ResourcesPlugin.getWorkspace().addResourceChangeListener(
-				listener,
-				IResourceChangeEvent.PRE_BUILD + IResourceChangeEvent.POST_BUILD);
-	}
-
-	/** Shutdown the singleton instance. */
-	public static void shutdown() {
-
-		// Bail if we're not started.
-		if (listener == null)
-			return;
-
-		// Deregister as save participant.
-		ResourcesPlugin.getWorkspace().removeSaveParticipant(FacesConfigPlugin.getPlugin().getBundle().getSymbolicName());
-
-		// Deregister as resource change listener.
-		ResourcesPlugin.getWorkspace().removeResourceChangeListener(listener);
-
-		// Dereference the singleton instance.
-		listener = null;
-	}
-
-	/**
-	 * Only this class can create instances.
-	 */
-	private FacesResourceChangeListener() {
-        // no local instantiation
-	}
-
-	/**
-	 * Process a resource change event. This should be invoked only from the
-	 * workbench.
-	 * 
-	 * @see IResourceChangeListener#resourceChanged(IResourceChangeEvent)
-	 */
-	public void resourceChanged(IResourceChangeEvent event) {
-
-		IResourceDelta delta = event.getDelta();
-		if (delta != null) {
-			FacesConfigChangeEvent facesConfigChangeEvent = new FacesConfigChangeEvent();
-			fireFacesConfigChangeEvent(facesConfigChangeEvent);
-
-			try {
-				delta.accept(this);
-			} catch (CoreException ignored) {
-				Logger.log(this, ignored);
-			}
-		}
-
-		// Restart projects, if necessary.
-		if ((delta != null) && (event.getType() == IResourceChangeEvent.POST_BUILD)) {
-			FacesConfigRestartServerResourceDeltaVisitor visitor = new FacesConfigRestartServerResourceDeltaVisitor();
-			try {
-				delta.accept(visitor);
-			} catch (CoreException ignored) {
-				Logger.log(this, ignored);
-			}
-			//restartComponents(visitor.getComponents());
-		}
-	}
-
-	/**
-	 * Visit a resource delta. This should be invoked only from the
-	 * IResourceDelta.accept() method invoked above.
-	 * 
-	 * @see IResourceDeltaVisitor#visit(IResourceDelta)
-	 */
-	public boolean visit(IResourceDelta delta) throws CoreException {
-
-		// Check for and handle it if it's a Struts config. file.
-		checkForFacesConfigFile(delta);
-
-		// Done.
-		return true;
-	}
-
-	private void checkForFacesConfigFile(IResourceDelta delta) {
-		boolean isAdded = delta.getKind() == IResourceDelta.ADDED;
-		if (isAdded
-				|| ((delta.getKind() == IResourceDelta.CHANGED) && ((delta.getFlags() & (IResourceDelta.CONTENT
-						| IResourceDelta.TYPE | IResourceDelta.SYNC | IResourceDelta.REPLACED)) != 0))) {
-			checkForFacesConfigFile(delta.getResource(), !isAdded);
-		}
-	}
-
-	private void checkForFacesConfigFile(IResource resource, boolean ignoreNonFacesProjects) {
-		if (resource.getType() == IResource.FILE) {
-
-			// See if the file is a Struts config. file.
-			// If the file was just added, we check the file regardless of
-			// whether or not it is in a Struts project.
-			// Otherwise, a file in a non-Struts project is considered to not be
-			// a Struts config. file.
-			IFile file = (IFile) resource;
-			if (FacesConfigUtil.isFacesConfigFile(file, ignoreNonFacesProjects)) {
-
-				// Ensure that the project has the Struts nature.
-				// TODO:
-				// StrutsNatureRuntime.ensureProjectHasStrutsNature(file.getProject());
-				IVirtualComponent component = ComponentUtilities.findComponent(file);
-				if (component != null) {
-					restartServerIfNecessary(component);
-					// Try to register the SCFE as the default editor.
-					setRegistration(file);
-				}
-			} else {
-				// Try to unregister the SCFE as the default editor.
-				unsetRegistration(file);
-			}
-		}
-	}
-
-	/**
-	 * Look to see if the persisted resource level property keyed by EDITOR_KEY
-	 * has ben set yet. If not then set it to the SCFE.
-	 * 
-	 * @param file
-	 *            The FCF
-	 */
-	private void setRegistration(IFile file) {
-		String editorID = null;
-		try {
-			editorID = file.getPersistentProperty(EDITOR_KEY);
-		} catch (CoreException e) {
-            // suppress core exception
-		}
-		if (editorID == null) {
-			try {
-				file.setPersistentProperty(EDITOR_KEY, FacesConfigPlugin.FACES_CONFIG_EDITOR_ID);
-			} catch (CoreException e) {
-				Logger.log(file, "Failed to set the vcurrent editor to SCFE", e); //$NON-NLS-1$
-			}
-		}
-	}
-
-	private void unsetRegistration(IFile file) {
-		// If the default editor for this file is not the Struts config. editor,
-		// then we're done.
-		IEditorRegistry registry = PlatformUI.getWorkbench().getEditorRegistry();
-		IEditorDescriptor userEditor = registry.getDefaultEditor(file.getFullPath().toString());
-		if ((userEditor == null)
-				|| !FacesConfigPlugin.FACES_CONFIG_EDITOR_ID.equals(userEditor.getId())) {
-			traceFiner(file, "Not unsetting: Default already not Faces config. editor"); //$NON-NLS-1$
-			return;
-		}
-
-		// Make the Struts config. editor the default.
-		traceFiner(file, "Unsetting."); //$NON-NLS-1$
-		IEditorDescriptor[] editors = registry.getEditors(file.getFullPath().toString());
-		if (editors.length > 1) {
-			registry.setDefaultEditor(file.getFullPath().toString(), editors[1].getId());
-		}
-	}
-
-	//private boolean isRestarting = false;
-	//private Collection restartableComponents = new HashSet();
-
-/*	private void restartComponents(Collection components) {
-		restartableComponents.addAll(components);
-		if (!isRestarting) {
-			isRestarting = true;
-			try {
-				while (!restartableComponents.isEmpty()) {
-					IVirtualComponent component = (IVirtualComponent) restartableComponents.iterator().next();
-					try {
-						ServerRestartUtil.restartComponent(component, true);
-					} finally {
-						restartableComponents.remove(component);
-					}
-				}
-			} finally {
-				isRestarting = false;
-			}
-
-		}
-	}
-
-*/	private void traceFiner(IFile file, String message) {
-		String fileName = file.getProjectRelativePath().toString();
-		Logger.trace("FacesconfigPlugin", this, fileName + ": " + message); //$NON-NLS-1$ //$NON-NLS-2$
-	}
-
-	/** @see ISaveParticipant#doneSaving(ISaveContext) */
-	public void doneSaving(ISaveContext context) {
-        // nothing to do
-	}
-
-	/** @see ISaveParticipant#prepareToSave(ISaveContext) */
-	public void prepareToSave(ISaveContext context) throws CoreException {
-        // nothing to do
-	}
-
-	/** @see ISaveParticipant#rollback(ISaveContext) */
-	public void rollback(ISaveContext context) {
-	    // nothing to do
-	}
-
-	/** @see ISaveParticipant#saving(ISaveContext) */
-	public void saving(ISaveContext context) throws CoreException {
-		context.needDelta();
-	}
-
-	/**
-	 * Visit a resource. This should be invoked only from the
-	 * IResource.accept(IResourceVisitor) invocation, above.
-	 * 
-	 * @see IResourceVisitor#visit(IResource)
-	 */
-	public boolean visit(IResource resource) {
-
-		// Check for and handle a Struts config. file.
-		checkForFacesConfigFile(resource, true);
-
-		// Continue.
-		return true;
-	}
-
-	private void restartServerIfNecessary(IVirtualComponent component) {
-		if(!restartInProgress) {
-			// check against preference about whether to automatically restart
-			boolean restart = false;
-			if (FacesResourceChangeListener.preferenceStore != null) {
-				restart = FacesResourceChangeListener.preferenceStore.getBoolean(IFacesconfigPreferences.PREFSKEY_SERVER_RESTART);
-			}
-			if(restart) {
-				restartInProgress = true;
-				// we'll ask that just the containing EAR is restarted, but it may cycle the whole server if running on Portal
-
-				//ServerRestartUtil.restartComponent(component, true);
-				restartInProgress = false;
-			}
-		}
-	}
-
-	/**
-	 * @return Returns the listener.
-	 */
-	public static FacesResourceChangeListener getFacesResourceChangeListener() {
-		if (listener == null) {
-			listener = new FacesResourceChangeListener();
-			// Register as resource change listener.
-			ResourcesPlugin.getWorkspace().addResourceChangeListener(listener, IResourceChangeEvent.PRE_BUILD);
-		}
-		return listener;
-	}
-	
-	/**
-	 * Adds a change listener to the list of listeners that will be notified
-	 * when a change is fired.
-	 * 
-	 * @param facesConfigChangeListener
-	 */
-	public void addFacesConfigChangeListener(IFacesConfigChangeListener facesConfigChangeListener) {
-		facesConfigChangeListeners.add(facesConfigChangeListener);
-	}
-	/**
-	 * Removes the listener from the list.
-	 * 
-	 * @param facesConfigChangeListener
-	 */
-	public void removeFacesConfigChangeListener(IFacesConfigChangeListener facesConfigChangeListener) {
-		facesConfigChangeListeners.remove(facesConfigChangeListener);
-	}
-	
-	private void fireFacesConfigChangeEvent(IFacesConfigChangeEvent event) {
-		LinkedList localCopy;
-		synchronized( this ) {
-			localCopy = (LinkedList)facesConfigChangeListeners.clone();
-		}
-		for ( ListIterator iter = localCopy.listIterator(); iter.hasNext(); ) {
-			IFacesConfigChangeListener facesConfigChangeListener = (IFacesConfigChangeListener)iter.next();
-			facesConfigChangeListener.resourceChanged(event);
-		}
-	}
-
-	/** 
-	 * Set the internally used preference store to preferenceStore
-	 * 
-	 * @param preferenceStore
-	 */
-	public static void setPreferenceStore(IPreferenceStore preferenceStore) {
-		FacesResourceChangeListener.preferenceStore = preferenceStore;
-	}
-}
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/IFacesConfigChangeEvent.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/IFacesConfigChangeEvent.java
deleted file mode 100644
index 5764ee8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/IFacesConfigChangeEvent.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.util;
-
-/**
- * Not intended for external use.
- * 
- * @author xnjiang
- *
- */
-/*package*/ interface IFacesConfigChangeEvent {
-
-	/**
-	 * @return true if a managed bean has changed
-	 */
-	public boolean isManagedBeanChanged();
-	/**
-	 * @return true if a navigation rule has changed
-	 */
-	public boolean isNavigationRuleChanged();
-	
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/IFacesConfigChangeListener.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/IFacesConfigChangeListener.java
deleted file mode 100644
index 393e61b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/IFacesConfigChangeListener.java
+++ /dev/null
@@ -1,26 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.util;
-
-
-/**
- * Not intended for external use.
- * 
- * @author xnjiang
- *
- */
-/*package*/interface IFacesConfigChangeListener {
-
-	/**
-	 * @param event
-	 */
-	public void resourceChanged(IFacesConfigChangeEvent event);
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/IFacesConfigConstants.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/IFacesConfigConstants.java
deleted file mode 100644
index 017bd29..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/IFacesConfigConstants.java
+++ /dev/null
@@ -1,23 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.util;
-
-/**
- * Not intended for external use.
- * 
- * Common constants
- */
-/*package*/ interface IFacesConfigConstants {
-	/**
-	 * the relative URI for the default faces config file.
-	 */
-	final String FACES_CONFIG_URI		= 	"WEB-INF/faces-config.xml"; //$NON-NLS-1$
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/IFacesConfigResource.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/IFacesConfigResource.java
deleted file mode 100644
index f2f1cce..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/IFacesConfigResource.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.util;
-
-
-import org.eclipse.jst.jsf.facesconfig.emf.FacesConfigType;
-import org.eclipse.wst.common.internal.emf.resource.TranslatorResource;
-
-
-/**
- * Should not be used or extended by clients.
- * 
- * @author gjohnsto
- * @version $Id$
- */
-/*package*/ interface IFacesConfigResource extends TranslatorResource {
-	
-	/**
-	 * @return the root faces config object
-	 */
-	public FacesConfigType getFacesConfig();
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/IFacesconfigPreferences.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/IFacesconfigPreferences.java
deleted file mode 100644
index 78c4222..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/IFacesconfigPreferences.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- **************************************************************************************************/
-package org.eclipse.jst.jsf.facesconfig.util;
-
-/**
- * Should NOT be used or extended by clients.
- * 
- * constants for JSF preferences pages
- *
- * @author spaxton
- */
-/*package*/ interface IFacesconfigPreferences {
-	
-	/**
-	 * Preference for whether or not to restart the server
-	 */
-	String PREFSKEY_SERVER_RESTART = "jsf.project.restart"; //$NON-NLS-1$
-	
-}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/package-info.java b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/package-info.java
deleted file mode 100644
index 5308b76..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/facesconfig/org/eclipse/jst/jsf/facesconfig/util/package-info.java
+++ /dev/null
@@ -1,19 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008 Oracle Corporation.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    Oracle - initial API and implementation
- *    
- ********************************************************************************/
-
-/**
- * Utility classes for JSF application configuration files.
- * <p>
- * Contents of this package maybe refactored in the future to other packages.  
- * Users must be prepared to refactor in the future. 
- */
-package org.eclipse.jst.jsf.facesconfig.util;
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAbsoluteOrderingType_name_NameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAbsoluteOrderingType_name_NameType.gif
deleted file mode 100644
index 33422e6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAbsoluteOrderingType_name_NameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAbsoluteOrderingType_others_OrderingOthersType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAbsoluteOrderingType_others_OrderingOthersType.gif
deleted file mode 100644
index 60a9ea3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAbsoluteOrderingType_others_OrderingOthersType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_actionListener_ActionListenerType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_actionListener_ActionListenerType.gif
deleted file mode 100644
index decea7b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_actionListener_ActionListenerType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_defaultRenderKitId_DefaultRenderKitIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_defaultRenderKitId_DefaultRenderKitIdType.gif
deleted file mode 100644
index b806b6d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_defaultRenderKitId_DefaultRenderKitIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_localeConfig_LocaleConfigType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_localeConfig_LocaleConfigType.gif
deleted file mode 100644
index 9b0e092..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_localeConfig_LocaleConfigType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_messageBundle_MessageBundleType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_messageBundle_MessageBundleType.gif
deleted file mode 100644
index 65e5a9b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_messageBundle_MessageBundleType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_navigationHandler_NavigationHandlerType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_navigationHandler_NavigationHandlerType.gif
deleted file mode 100644
index 5bbeb62..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_navigationHandler_NavigationHandlerType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_partialTraversal_PartialTraversalType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_partialTraversal_PartialTraversalType.gif
deleted file mode 100644
index 82914f2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_partialTraversal_PartialTraversalType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_propertyResolver_PropertyResolverType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_propertyResolver_PropertyResolverType.gif
deleted file mode 100644
index 0b5f0b5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_propertyResolver_PropertyResolverType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_resourceHandler_ResourceHandlerType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_resourceHandler_ResourceHandlerType.gif
deleted file mode 100644
index a9b580a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_resourceHandler_ResourceHandlerType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_stateManager_StateManagerType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_stateManager_StateManagerType.gif
deleted file mode 100644
index 9ef55d2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_stateManager_StateManagerType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_variableResolver_VariableResolverType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_variableResolver_VariableResolverType.gif
deleted file mode 100644
index d7dcab4..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_variableResolver_VariableResolverType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_viewHandler_ViewHandlerType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_viewHandler_ViewHandlerType.gif
deleted file mode 100644
index 89171a9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateApplicationType_viewHandler_ViewHandlerType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_attributeClass_AttributeClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_attributeClass_AttributeClassType.gif
deleted file mode 100644
index e30458a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_attributeClass_AttributeClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_attributeExtension_AttributeExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_attributeExtension_AttributeExtensionType.gif
deleted file mode 100644
index b067e51..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_attributeExtension_AttributeExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_attributeName_AttributeNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_attributeName_AttributeNameType.gif
deleted file mode 100644
index f420604..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_attributeName_AttributeNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_defaultValue_DefaultValueType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_defaultValue_DefaultValueType.gif
deleted file mode 100644
index 4792e17..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_defaultValue_DefaultValueType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_description_DescriptionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_description_DescriptionType.gif
deleted file mode 100644
index 92d407e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_description_DescriptionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_displayName_DisplayNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_displayName_DisplayNameType.gif
deleted file mode 100644
index 09b5568..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_displayName_DisplayNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_icon_IconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_icon_IconType.gif
deleted file mode 100644
index de6e628..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_icon_IconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_suggestedValue_SuggestedValueType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_suggestedValue_SuggestedValueType.gif
deleted file mode 100644
index 3dfc8ee..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateAttributeType_suggestedValue_SuggestedValueType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_attribute_AttributeType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_attribute_AttributeType.gif
deleted file mode 100644
index 282803a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_attribute_AttributeType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_behaviorClass_BehaviorClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_behaviorClass_BehaviorClassType.gif
deleted file mode 100644
index 61ec24a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_behaviorClass_BehaviorClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_behaviorExtension_BehaviorExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_behaviorExtension_BehaviorExtensionType.gif
deleted file mode 100644
index 736cfc2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_behaviorExtension_BehaviorExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_behaviorId_BehaviorIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_behaviorId_BehaviorIdType.gif
deleted file mode 100644
index 138909e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_behaviorId_BehaviorIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_description_DescriptionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_description_DescriptionType.gif
deleted file mode 100644
index 9bf9328..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_description_DescriptionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_displayName_DisplayNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_displayName_DisplayNameType.gif
deleted file mode 100644
index bb4722e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_displayName_DisplayNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_icon_IconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_icon_IconType.gif
deleted file mode 100644
index c46fd65..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_icon_IconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_property_PropertyType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_property_PropertyType.gif
deleted file mode 100644
index ec93a66..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateBehaviorType_property_PropertyType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateClientBehaviorRendererType_clientBehaviorRendererClass_ClientBehaviorRendererClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateClientBehaviorRendererType_clientBehaviorRendererClass_ClientBehaviorRendererClassType.gif
deleted file mode 100644
index e27a4de..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateClientBehaviorRendererType_clientBehaviorRendererClass_ClientBehaviorRendererClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateClientBehaviorRendererType_clientBehaviorRendererType_ClientBehaviorRendererTypeType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateClientBehaviorRendererType_clientBehaviorRendererType_ClientBehaviorRendererTypeType.gif
deleted file mode 100644
index 4d8faab..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateClientBehaviorRendererType_clientBehaviorRendererType_ClientBehaviorRendererTypeType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_attribute_AttributeType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_attribute_AttributeType.gif
deleted file mode 100644
index 086cf80..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_attribute_AttributeType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_componentClass_ComponentClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_componentClass_ComponentClassType.gif
deleted file mode 100644
index 4bbe527..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_componentClass_ComponentClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_componentExtension_ComponentExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_componentExtension_ComponentExtensionType.gif
deleted file mode 100644
index 1b6026a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_componentExtension_ComponentExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_componentType_ComponentTypeType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_componentType_ComponentTypeType.gif
deleted file mode 100644
index 803d12d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_componentType_ComponentTypeType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_description_DescriptionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_description_DescriptionType.gif
deleted file mode 100644
index 4154e57..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_description_DescriptionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_displayName_DisplayNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_displayName_DisplayNameType.gif
deleted file mode 100644
index 6cb8e23..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_displayName_DisplayNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_facet_FacetType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_facet_FacetType.gif
deleted file mode 100644
index f91a995..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_facet_FacetType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_icon_IconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_icon_IconType.gif
deleted file mode 100644
index b24124a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_icon_IconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_property_PropertyType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_property_PropertyType.gif
deleted file mode 100644
index 3a05916..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateComponentType_property_PropertyType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_attribute_AttributeType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_attribute_AttributeType.gif
deleted file mode 100644
index f4fa5b5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_attribute_AttributeType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_converterClass_ConverterClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_converterClass_ConverterClassType.gif
deleted file mode 100644
index d886763..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_converterClass_ConverterClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_converterExtension_ConverterExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_converterExtension_ConverterExtensionType.gif
deleted file mode 100644
index d544289..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_converterExtension_ConverterExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_converterForClass_ConverterForClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_converterForClass_ConverterForClassType.gif
deleted file mode 100644
index e01c9cf..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_converterForClass_ConverterForClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_converterId_ConverterIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_converterId_ConverterIdType.gif
deleted file mode 100644
index b95bc38..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_converterId_ConverterIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_description_DescriptionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_description_DescriptionType.gif
deleted file mode 100644
index 43703db..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_description_DescriptionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_displayName_DisplayNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_displayName_DisplayNameType.gif
deleted file mode 100644
index e7c430b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_displayName_DisplayNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_icon_IconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_icon_IconType.gif
deleted file mode 100644
index 265ce22..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_icon_IconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_property_PropertyType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_property_PropertyType.gif
deleted file mode 100644
index 3fbe2cd..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateConverterType_property_PropertyType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDefaultValidatorsType_validatorId_ValidatorIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDefaultValidatorsType_validatorId_ValidatorIdType.gif
deleted file mode 100644
index af09eb6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDefaultValidatorsType_validatorId_ValidatorIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_absoluteOrdering_AbsoluteOrderingType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_absoluteOrdering_AbsoluteOrderingType.gif
deleted file mode 100644
index d757ea0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_absoluteOrdering_AbsoluteOrderingType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_actionListener_ActionListenerType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_actionListener_ActionListenerType.gif
deleted file mode 100644
index 9dd025a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_actionListener_ActionListenerType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_applicationFactory_ApplicationFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_applicationFactory_ApplicationFactoryType.gif
deleted file mode 100644
index 1c7362a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_applicationFactory_ApplicationFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_application_ApplicationType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_application_ApplicationType.gif
deleted file mode 100644
index 29e698e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_application_ApplicationType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_attributeClass_AttributeClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_attributeClass_AttributeClassType.gif
deleted file mode 100644
index 784f9df..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_attributeClass_AttributeClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_attributeExtension_AttributeExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_attributeExtension_AttributeExtensionType.gif
deleted file mode 100644
index af07ba1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_attributeExtension_AttributeExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_attributeName_AttributeNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_attributeName_AttributeNameType.gif
deleted file mode 100644
index 5d5000a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_attributeName_AttributeNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_attribute_AttributeType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_attribute_AttributeType.gif
deleted file mode 100644
index 5d9762d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_attribute_AttributeType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_behaviorClass_BehaviorClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_behaviorClass_BehaviorClassType.gif
deleted file mode 100644
index 98bbe95..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_behaviorClass_BehaviorClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_behaviorExtension_BehaviorExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_behaviorExtension_BehaviorExtensionType.gif
deleted file mode 100644
index f8b3c3d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_behaviorExtension_BehaviorExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_behaviorId_BehaviorIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_behaviorId_BehaviorIdType.gif
deleted file mode 100644
index ed6d815..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_behaviorId_BehaviorIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_behavior_BehaviorType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_behavior_BehaviorType.gif
deleted file mode 100644
index 0c17af8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_behavior_BehaviorType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_componentClass_ComponentClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_componentClass_ComponentClassType.gif
deleted file mode 100644
index 0a7b807..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_componentClass_ComponentClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_componentExtension_ComponentExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_componentExtension_ComponentExtensionType.gif
deleted file mode 100644
index 62bda1f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_componentExtension_ComponentExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_componentFamily_ComponentFamilyType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_componentFamily_ComponentFamilyType.gif
deleted file mode 100644
index b76c403..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_componentFamily_ComponentFamilyType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_componentType_ComponentTypeType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_componentType_ComponentTypeType.gif
deleted file mode 100644
index b25c629..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_componentType_ComponentTypeType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_component_ComponentType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_component_ComponentType.gif
deleted file mode 100644
index d70b2d9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_component_ComponentType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_converterClass_ConverterClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_converterClass_ConverterClassType.gif
deleted file mode 100644
index ced57c5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_converterClass_ConverterClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_converterForClass_ConverterForClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_converterForClass_ConverterForClassType.gif
deleted file mode 100644
index 5ac5ee0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_converterForClass_ConverterForClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_converterId_ConverterIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_converterId_ConverterIdType.gif
deleted file mode 100644
index c2aa3b3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_converterId_ConverterIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_converter_ConverterType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_converter_ConverterType.gif
deleted file mode 100644
index 0855183..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_converter_ConverterType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_defaultLocale_DefaultLocaleType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_defaultLocale_DefaultLocaleType.gif
deleted file mode 100644
index a1fa94e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_defaultLocale_DefaultLocaleType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_defaultRenderKitId_DefaultRenderKitIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_defaultRenderKitId_DefaultRenderKitIdType.gif
deleted file mode 100644
index db9e527..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_defaultRenderKitId_DefaultRenderKitIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_defaultValidators_DefaultValidatorsType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_defaultValidators_DefaultValidatorsType.gif
deleted file mode 100644
index d218932..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_defaultValidators_DefaultValidatorsType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_defaultValue_DefaultValueType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_defaultValue_DefaultValueType.gif
deleted file mode 100644
index c2aa3b3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_defaultValue_DefaultValueType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_description_DescriptionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_description_DescriptionType.gif
deleted file mode 100644
index 1c7362a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_description_DescriptionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_displayName_DisplayNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_displayName_DisplayNameType.gif
deleted file mode 100644
index 1d2f734..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_displayName_DisplayNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_exceptionHandlerFactory_ExceptionHandlerFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_exceptionHandlerFactory_ExceptionHandlerFactoryType.gif
deleted file mode 100644
index db9e527..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_exceptionHandlerFactory_ExceptionHandlerFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_externalContextFactory_ExternalContextFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_externalContextFactory_ExternalContextFactoryType.gif
deleted file mode 100644
index c3c2a8d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_externalContextFactory_ExternalContextFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_facesConfig_FacesConfigType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_facesConfig_FacesConfigType.gif
deleted file mode 100644
index 61b0302..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_facesConfig_FacesConfigType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_facesContextFactory_FacesContextFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_facesContextFactory_FacesContextFactoryType.gif
deleted file mode 100644
index 182638d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_facesContextFactory_FacesContextFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_facetExtension_FacetExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_facetExtension_FacetExtensionType.gif
deleted file mode 100644
index 7983736..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_facetExtension_FacetExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_facetName_FacetNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_facetName_FacetNameType.gif
deleted file mode 100644
index 42372e5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_facetName_FacetNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_facet_FacetType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_facet_FacetType.gif
deleted file mode 100644
index c5e260e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_facet_FacetType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_factory_FactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_factory_FactoryType.gif
deleted file mode 100644
index 983575c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_factory_FactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_fromAction_FromActionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_fromAction_FromActionType.gif
deleted file mode 100644
index 43794a2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_fromAction_FromActionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_fromOutcome_FromOutcomeType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_fromOutcome_FromOutcomeType.gif
deleted file mode 100644
index 86c2eb4..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_fromOutcome_FromOutcomeType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_fromViewId_FromViewIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_fromViewId_FromViewIdType.gif
deleted file mode 100644
index 52c7ec0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_fromViewId_FromViewIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_icon_IconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_icon_IconType.gif
deleted file mode 100644
index c05a418..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_icon_IconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_if_IfType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_if_IfType.gif
deleted file mode 100644
index e85f5d0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_if_IfType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_keyClass_KeyClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_keyClass_KeyClassType.gif
deleted file mode 100644
index d218932..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_keyClass_KeyClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_key_KeyType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_key_KeyType.gif
deleted file mode 100644
index c5e260e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_key_KeyType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_largeIcon_LargeIconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_largeIcon_LargeIconType.gif
deleted file mode 100644
index d757ea0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_largeIcon_LargeIconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_lifecycleFactory_LifecycleFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_lifecycleFactory_LifecycleFactoryType.gif
deleted file mode 100644
index 5599390..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_lifecycleFactory_LifecycleFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_lifecycle_LifecycleType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_lifecycle_LifecycleType.gif
deleted file mode 100644
index 908375c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_lifecycle_LifecycleType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_listEntries_ListEntriesType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_listEntries_ListEntriesType.gif
deleted file mode 100644
index d9a9d8d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_listEntries_ListEntriesType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_localeConfig_LocaleConfigType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_localeConfig_LocaleConfigType.gif
deleted file mode 100644
index 55f49ef..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_localeConfig_LocaleConfigType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_managedBeanClass_ManagedBeanClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_managedBeanClass_ManagedBeanClassType.gif
deleted file mode 100644
index 0091fd6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_managedBeanClass_ManagedBeanClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_managedBeanName_ManagedBeanNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_managedBeanName_ManagedBeanNameType.gif
deleted file mode 100644
index 5e4d339..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_managedBeanName_ManagedBeanNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_managedBeanScope_ManagedBeanScopeType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_managedBeanScope_ManagedBeanScopeType.gif
deleted file mode 100644
index 7983736..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_managedBeanScope_ManagedBeanScopeType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_managedBean_ManagedBeanType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_managedBean_ManagedBeanType.gif
deleted file mode 100644
index fc34e45..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_managedBean_ManagedBeanType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_managedProperty_ManagedPropertyType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_managedProperty_ManagedPropertyType.gif
deleted file mode 100644
index 963a72b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_managedProperty_ManagedPropertyType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_mapEntries_MapEntriesType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_mapEntries_MapEntriesType.gif
deleted file mode 100644
index 0a7b807..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_mapEntries_MapEntriesType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_mapEntry_MapEntryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_mapEntry_MapEntryType.gif
deleted file mode 100644
index 1c7362a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_mapEntry_MapEntryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_messageBundle_MessageBundleType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_messageBundle_MessageBundleType.gif
deleted file mode 100644
index 4ce1821..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_messageBundle_MessageBundleType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_name_NameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_name_NameType.gif
deleted file mode 100644
index 31de68f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_name_NameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_navigationCase_NavigationCaseType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_navigationCase_NavigationCaseType.gif
deleted file mode 100644
index 61b0302..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_navigationCase_NavigationCaseType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_navigationHandler_NavigationHandlerType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_navigationHandler_NavigationHandlerType.gif
deleted file mode 100644
index 0996300..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_navigationHandler_NavigationHandlerType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_navigationRule_NavigationRuleType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_navigationRule_NavigationRuleType.gif
deleted file mode 100644
index 64cd1b0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_navigationRule_NavigationRuleType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_nullValue_NullValueType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_nullValue_NullValueType.gif
deleted file mode 100644
index 3d308aa..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_nullValue_NullValueType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_orderingOrdering_OrderingOrderingType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_orderingOrdering_OrderingOrderingType.gif
deleted file mode 100644
index 4a972b8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_orderingOrdering_OrderingOrderingType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_ordering_OrderingType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_ordering_OrderingType.gif
deleted file mode 100644
index c0890af..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_ordering_OrderingType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_others_OrderingOthersType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_others_OrderingOthersType.gif
deleted file mode 100644
index 42372e5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_others_OrderingOthersType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_partialTraversal_PartialTraversalType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_partialTraversal_PartialTraversalType.gif
deleted file mode 100644
index d218932..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_partialTraversal_PartialTraversalType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_partialViewContextFactory_PartialViewContextFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_partialViewContextFactory_PartialViewContextFactoryType.gif
deleted file mode 100644
index ed5f660..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_partialViewContextFactory_PartialViewContextFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_phaseListener_PhaseListenerType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_phaseListener_PhaseListenerType.gif
deleted file mode 100644
index 464e623..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_phaseListener_PhaseListenerType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_propertyClass_PropertyClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_propertyClass_PropertyClassType.gif
deleted file mode 100644
index b76c403..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_propertyClass_PropertyClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_propertyExtension_PropertyExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_propertyExtension_PropertyExtensionType.gif
deleted file mode 100644
index 182638d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_propertyExtension_PropertyExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_propertyName_PropertyNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_propertyName_PropertyNameType.gif
deleted file mode 100644
index 7983736..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_propertyName_PropertyNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_propertyResolver_PropertyResolverType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_propertyResolver_PropertyResolverType.gif
deleted file mode 100644
index af07ba1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_propertyResolver_PropertyResolverType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_property_PropertyType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_property_PropertyType.gif
deleted file mode 100644
index 448138d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_property_PropertyType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_redirectViewParam_RedirectViewParamType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_redirectViewParam_RedirectViewParamType.gif
deleted file mode 100644
index 9a093da..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_redirectViewParam_RedirectViewParamType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_redirect_RedirectType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_redirect_RedirectType.gif
deleted file mode 100644
index 55f49ef..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_redirect_RedirectType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_referencedBeanClass_ReferencedBeanClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_referencedBeanClass_ReferencedBeanClassType.gif
deleted file mode 100644
index ed6d815..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_referencedBeanClass_ReferencedBeanClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_referencedBeanName_ReferencedBeanNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_referencedBeanName_ReferencedBeanNameType.gif
deleted file mode 100644
index 96c0245..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_referencedBeanName_ReferencedBeanNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_referencedBean_ReferencedBeanType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_referencedBean_ReferencedBeanType.gif
deleted file mode 100644
index 3d308aa..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_referencedBean_ReferencedBeanType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_renderKitClass_RenderKitClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_renderKitClass_RenderKitClassType.gif
deleted file mode 100644
index 3f3e603..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_renderKitClass_RenderKitClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_renderKitFactory_RenderKitFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_renderKitFactory_RenderKitFactoryType.gif
deleted file mode 100644
index 3d308aa..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_renderKitFactory_RenderKitFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_renderKitId_RenderKitIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_renderKitId_RenderKitIdType.gif
deleted file mode 100644
index 7fa1f08..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_renderKitId_RenderKitIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_renderKit_RenderKitType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_renderKit_RenderKitType.gif
deleted file mode 100644
index 75a50e9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_renderKit_RenderKitType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_rendererClass_RendererClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_rendererClass_RendererClassType.gif
deleted file mode 100644
index d218932..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_rendererClass_RendererClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_rendererExtension_RendererExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_rendererExtension_RendererExtensionType.gif
deleted file mode 100644
index 983575c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_rendererExtension_RendererExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_rendererType_RendererTypeType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_rendererType_RendererTypeType.gif
deleted file mode 100644
index c882b04..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_rendererType_RendererTypeType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_renderer_RendererType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_renderer_RendererType.gif
deleted file mode 100644
index e178517..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_renderer_RendererType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_resourceHandler_ResourceHandlerType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_resourceHandler_ResourceHandlerType.gif
deleted file mode 100644
index 5106f50..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_resourceHandler_ResourceHandlerType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_smallIcon_SmallIconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_smallIcon_SmallIconType.gif
deleted file mode 100644
index 76b41e3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_smallIcon_SmallIconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_sourceClass_SourceClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_sourceClass_SourceClassType.gif
deleted file mode 100644
index 3f3e603..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_sourceClass_SourceClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_stateManager_StateManagerType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_stateManager_StateManagerType.gif
deleted file mode 100644
index eef1935..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_stateManager_StateManagerType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_suggestedValue_SuggestedValueType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_suggestedValue_SuggestedValueType.gif
deleted file mode 100644
index d49c17d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_suggestedValue_SuggestedValueType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_supportedLocale_SupportedLocaleType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_supportedLocale_SupportedLocaleType.gif
deleted file mode 100644
index 4ce1821..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_supportedLocale_SupportedLocaleType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_systemEventClass_SystemEventClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_systemEventClass_SystemEventClassType.gif
deleted file mode 100644
index db9e527..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_systemEventClass_SystemEventClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_systemEventListenerClass_SystemEventListenerClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_systemEventListenerClass_SystemEventListenerClassType.gif
deleted file mode 100644
index 9a093da..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_systemEventListenerClass_SystemEventListenerClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_systemEventListener_SystemEventListenerType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_systemEventListener_SystemEventListenerType.gif
deleted file mode 100644
index d757ea0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_systemEventListener_SystemEventListenerType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_tagHandlerDelegateFactory_TagHandlerDelegateFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_tagHandlerDelegateFactory_TagHandlerDelegateFactoryType.gif
deleted file mode 100644
index 9932a4b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_tagHandlerDelegateFactory_TagHandlerDelegateFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_toViewId_ToViewIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_toViewId_ToViewIdType.gif
deleted file mode 100644
index 96c0245..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_toViewId_ToViewIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_validatorClass_ValidatorClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_validatorClass_ValidatorClassType.gif
deleted file mode 100644
index 0091fd6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_validatorClass_ValidatorClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_validatorId_ValidatorIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_validatorId_ValidatorIdType.gif
deleted file mode 100644
index 9a093da..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_validatorId_ValidatorIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_validator_ValidatorType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_validator_ValidatorType.gif
deleted file mode 100644
index fc34e45..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_validator_ValidatorType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_valueClass_ValueClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_valueClass_ValueClassType.gif
deleted file mode 100644
index 48b9e69..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_valueClass_ValueClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_value_ValueType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_value_ValueType.gif
deleted file mode 100644
index 411e41c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_value_ValueType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_variableResolver_VariableResolverType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_variableResolver_VariableResolverType.gif
deleted file mode 100644
index 210e156..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_variableResolver_VariableResolverType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_viewDeclarationLanguageFactory_ViewDeclarationLanguageFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_viewDeclarationLanguageFactory_ViewDeclarationLanguageFactoryType.gif
deleted file mode 100644
index 96c0245..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_viewDeclarationLanguageFactory_ViewDeclarationLanguageFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_viewHandler_ViewHandlerType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_viewHandler_ViewHandlerType.gif
deleted file mode 100644
index 84df4c1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_viewHandler_ViewHandlerType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_visitContextFactory_VisitContextFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_visitContextFactory_VisitContextFactoryType.gif
deleted file mode 100644
index 5ac5ee0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDocumentRoot_visitContextFactory_VisitContextFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDynamicElement_childNodes_DynamicElement.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDynamicElement_childNodes_DynamicElement.gif
deleted file mode 100644
index 3744cee..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateDynamicElement_childNodes_DynamicElement.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_absoluteOrdering_AbsoluteOrderingType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_absoluteOrdering_AbsoluteOrderingType.gif
deleted file mode 100644
index a85a8b8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_absoluteOrdering_AbsoluteOrderingType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_application_ApplicationType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_application_ApplicationType.gif
deleted file mode 100644
index 28ed761..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_application_ApplicationType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_behavior_BehaviorType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_behavior_BehaviorType.gif
deleted file mode 100644
index 65fff8e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_behavior_BehaviorType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_component_ComponentType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_component_ComponentType.gif
deleted file mode 100644
index 07b82ef..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_component_ComponentType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_converter_ConverterType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_converter_ConverterType.gif
deleted file mode 100644
index b4db3ff..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_converter_ConverterType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_factory_FactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_factory_FactoryType.gif
deleted file mode 100644
index ca61c9e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_factory_FactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_lifecycle_LifecycleType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_lifecycle_LifecycleType.gif
deleted file mode 100644
index b93b3d2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_lifecycle_LifecycleType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_managedBean_ManagedBeanType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_managedBean_ManagedBeanType.gif
deleted file mode 100644
index f2b0a1e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_managedBean_ManagedBeanType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_name_NameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_name_NameType.gif
deleted file mode 100644
index c7c2185..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_name_NameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_navigationRule_NavigationRuleType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_navigationRule_NavigationRuleType.gif
deleted file mode 100644
index 7431442..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_navigationRule_NavigationRuleType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_ordering_OrderingType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_ordering_OrderingType.gif
deleted file mode 100644
index 2bf84ea..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_ordering_OrderingType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_referencedBean_ReferencedBeanType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_referencedBean_ReferencedBeanType.gif
deleted file mode 100644
index 149a215..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_referencedBean_ReferencedBeanType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_renderKit_RenderKitType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_renderKit_RenderKitType.gif
deleted file mode 100644
index 8cd9cfa..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_renderKit_RenderKitType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_validator_ValidatorType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_validator_ValidatorType.gif
deleted file mode 100644
index f2b0a1e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacesConfigType_validator_ValidatorType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacetType_description_DescriptionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacetType_description_DescriptionType.gif
deleted file mode 100644
index 66a097b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacetType_description_DescriptionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacetType_displayName_DisplayNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacetType_displayName_DisplayNameType.gif
deleted file mode 100644
index dd919f9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacetType_displayName_DisplayNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacetType_facetExtension_FacetExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacetType_facetExtension_FacetExtensionType.gif
deleted file mode 100644
index b021070..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacetType_facetExtension_FacetExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacetType_facetName_FacetNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacetType_facetName_FacetNameType.gif
deleted file mode 100644
index ff4cc72..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacetType_facetName_FacetNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacetType_icon_IconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacetType_icon_IconType.gif
deleted file mode 100644
index df2b32d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFacetType_icon_IconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_applicationFactory_ApplicationFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_applicationFactory_ApplicationFactoryType.gif
deleted file mode 100644
index d4a978d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_applicationFactory_ApplicationFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_exceptionHandlerFactory_ExceptionHandlerFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_exceptionHandlerFactory_ExceptionHandlerFactoryType.gif
deleted file mode 100644
index a32a163..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_exceptionHandlerFactory_ExceptionHandlerFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_externalContextFactory_ExternalContextFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_externalContextFactory_ExternalContextFactoryType.gif
deleted file mode 100644
index 247d202..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_externalContextFactory_ExternalContextFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_facesContextFactory_FacesContextFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_facesContextFactory_FacesContextFactoryType.gif
deleted file mode 100644
index 5173b2d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_facesContextFactory_FacesContextFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_lifecycleFactory_LifecycleFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_lifecycleFactory_LifecycleFactoryType.gif
deleted file mode 100644
index 7cc18f1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_lifecycleFactory_LifecycleFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_partialViewContextFactory_PartialViewContextFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_partialViewContextFactory_PartialViewContextFactoryType.gif
deleted file mode 100644
index 13f7679..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_partialViewContextFactory_PartialViewContextFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_renderKitFactory_RenderKitFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_renderKitFactory_RenderKitFactoryType.gif
deleted file mode 100644
index 3dac10e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_renderKitFactory_RenderKitFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_tagHandlerDelegateFactory_TagHandlerDelegateFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_tagHandlerDelegateFactory_TagHandlerDelegateFactoryType.gif
deleted file mode 100644
index ca50a38..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_tagHandlerDelegateFactory_TagHandlerDelegateFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_viewDeclarationLanguageFactory_ViewDeclarationLanguageFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_viewDeclarationLanguageFactory_ViewDeclarationLanguageFactoryType.gif
deleted file mode 100644
index 31a4b78..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_viewDeclarationLanguageFactory_ViewDeclarationLanguageFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_visitContextFactory_VisitContextFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_visitContextFactory_VisitContextFactoryType.gif
deleted file mode 100644
index 9ea4eeb..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateFactoryType_visitContextFactory_VisitContextFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateIconType_largeIcon_LargeIconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateIconType_largeIcon_LargeIconType.gif
deleted file mode 100644
index 6a782d1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateIconType_largeIcon_LargeIconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateIconType_smallIcon_SmallIconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateIconType_smallIcon_SmallIconType.gif
deleted file mode 100644
index 0640cac..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateIconType_smallIcon_SmallIconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateLifecycleType_lifecycleExtension_LifecycleExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateLifecycleType_lifecycleExtension_LifecycleExtensionType.gif
deleted file mode 100644
index 79a0b58..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateLifecycleType_lifecycleExtension_LifecycleExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateLifecycleType_phaseListener_PhaseListenerType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateLifecycleType_phaseListener_PhaseListenerType.gif
deleted file mode 100644
index f11ad89..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateLifecycleType_phaseListener_PhaseListenerType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateListEntriesType_nullValue_NullValueType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateListEntriesType_nullValue_NullValueType.gif
deleted file mode 100644
index 205071f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateListEntriesType_nullValue_NullValueType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateListEntriesType_valueClass_ValueClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateListEntriesType_valueClass_ValueClassType.gif
deleted file mode 100644
index de5107d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateListEntriesType_valueClass_ValueClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateListEntriesType_value_ValueType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateListEntriesType_value_ValueType.gif
deleted file mode 100644
index a9aaa51..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateListEntriesType_value_ValueType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateLocaleConfigType_defaultLocale_DefaultLocaleType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateLocaleConfigType_defaultLocale_DefaultLocaleType.gif
deleted file mode 100644
index d5f8c8d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateLocaleConfigType_defaultLocale_DefaultLocaleType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateLocaleConfigType_supportedLocale_SupportedLocaleType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateLocaleConfigType_supportedLocale_SupportedLocaleType.gif
deleted file mode 100644
index 3e4fc3f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateLocaleConfigType_supportedLocale_SupportedLocaleType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_description_DescriptionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_description_DescriptionType.gif
deleted file mode 100644
index b913037..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_description_DescriptionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_displayName_DisplayNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_displayName_DisplayNameType.gif
deleted file mode 100644
index 23c1e15..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_displayName_DisplayNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_icon_IconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_icon_IconType.gif
deleted file mode 100644
index 46c6860..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_icon_IconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_listEntries_ListEntriesType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_listEntries_ListEntriesType.gif
deleted file mode 100644
index 3a9f24e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_listEntries_ListEntriesType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_managedBeanClass_ManagedBeanClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_managedBeanClass_ManagedBeanClassType.gif
deleted file mode 100644
index d5d9efe..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_managedBeanClass_ManagedBeanClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_managedBeanExtension_ManagedBeanExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_managedBeanExtension_ManagedBeanExtensionType.gif
deleted file mode 100644
index 10a1ab5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_managedBeanExtension_ManagedBeanExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_managedBeanName_ManagedBeanNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_managedBeanName_ManagedBeanNameType.gif
deleted file mode 100644
index 5df01fb..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_managedBeanName_ManagedBeanNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_managedBeanScope_ManagedBeanScopeType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_managedBeanScope_ManagedBeanScopeType.gif
deleted file mode 100644
index 615b448..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_managedBeanScope_ManagedBeanScopeType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_managedProperty_ManagedPropertyType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_managedProperty_ManagedPropertyType.gif
deleted file mode 100644
index f11830c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_managedProperty_ManagedPropertyType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_mapEntries_MapEntriesType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_mapEntries_MapEntriesType.gif
deleted file mode 100644
index 5e689e6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedBeanType_mapEntries_MapEntriesType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_description_DescriptionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_description_DescriptionType.gif
deleted file mode 100644
index e66386f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_description_DescriptionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_displayName_DisplayNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_displayName_DisplayNameType.gif
deleted file mode 100644
index c2b071b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_displayName_DisplayNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_icon_IconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_icon_IconType.gif
deleted file mode 100644
index 60aa17e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_icon_IconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_listEntries_ListEntriesType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_listEntries_ListEntriesType.gif
deleted file mode 100644
index 223e215..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_listEntries_ListEntriesType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_mapEntries_MapEntriesType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_mapEntries_MapEntriesType.gif
deleted file mode 100644
index db04142..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_mapEntries_MapEntriesType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_nullValue_NullValueType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_nullValue_NullValueType.gif
deleted file mode 100644
index 0bf86ce..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_nullValue_NullValueType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_propertyClass_PropertyClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_propertyClass_PropertyClassType.gif
deleted file mode 100644
index c0ace1e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_propertyClass_PropertyClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_propertyName_PropertyNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_propertyName_PropertyNameType.gif
deleted file mode 100644
index 377956d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_propertyName_PropertyNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_value_ValueType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_value_ValueType.gif
deleted file mode 100644
index 0ca5aa8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateManagedPropertyType_value_ValueType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateMapEntriesType_keyClass_KeyClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateMapEntriesType_keyClass_KeyClassType.gif
deleted file mode 100644
index 30e0107..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateMapEntriesType_keyClass_KeyClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateMapEntriesType_mapEntry_MapEntryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateMapEntriesType_mapEntry_MapEntryType.gif
deleted file mode 100644
index 2a3bcb3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateMapEntriesType_mapEntry_MapEntryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateMapEntriesType_valueClass_ValueClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateMapEntriesType_valueClass_ValueClassType.gif
deleted file mode 100644
index 5303d3a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateMapEntriesType_valueClass_ValueClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateMapEntryType_key_KeyType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateMapEntryType_key_KeyType.gif
deleted file mode 100644
index cd28dd3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateMapEntryType_key_KeyType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateMapEntryType_nullValue_NullValueType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateMapEntryType_nullValue_NullValueType.gif
deleted file mode 100644
index 799bbbb..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateMapEntryType_nullValue_NullValueType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateMapEntryType_value_ValueType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateMapEntryType_value_ValueType.gif
deleted file mode 100644
index 8d3cc41..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateMapEntryType_value_ValueType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_description_DescriptionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_description_DescriptionType.gif
deleted file mode 100644
index 1dd58e1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_description_DescriptionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_displayName_DisplayNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_displayName_DisplayNameType.gif
deleted file mode 100644
index 424142e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_displayName_DisplayNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_fromAction_FromActionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_fromAction_FromActionType.gif
deleted file mode 100644
index d628611..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_fromAction_FromActionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_fromOutcome_FromOutcomeType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_fromOutcome_FromOutcomeType.gif
deleted file mode 100644
index 0ca3dc5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_fromOutcome_FromOutcomeType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_icon_IconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_icon_IconType.gif
deleted file mode 100644
index 0f107c5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_icon_IconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_if_IfType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_if_IfType.gif
deleted file mode 100644
index 9987e74..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_if_IfType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_redirect_RedirectType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_redirect_RedirectType.gif
deleted file mode 100644
index a46fda5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_redirect_RedirectType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_toViewId_ToViewIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_toViewId_ToViewIdType.gif
deleted file mode 100644
index d3569a5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationCaseType_toViewId_ToViewIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationRuleType_description_DescriptionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationRuleType_description_DescriptionType.gif
deleted file mode 100644
index fbba57a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationRuleType_description_DescriptionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationRuleType_displayName_DisplayNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationRuleType_displayName_DisplayNameType.gif
deleted file mode 100644
index ae6f7b7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationRuleType_displayName_DisplayNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationRuleType_fromViewId_FromViewIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationRuleType_fromViewId_FromViewIdType.gif
deleted file mode 100644
index 95b0b4b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationRuleType_fromViewId_FromViewIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationRuleType_icon_IconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationRuleType_icon_IconType.gif
deleted file mode 100644
index fbae759..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationRuleType_icon_IconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationRuleType_navigationCase_NavigationCaseType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationRuleType_navigationCase_NavigationCaseType.gif
deleted file mode 100644
index 34611db..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationRuleType_navigationCase_NavigationCaseType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationRuleType_navigationRuleExtension_NavigationRuleExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationRuleType_navigationRuleExtension_NavigationRuleExtensionType.gif
deleted file mode 100644
index b0e719a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateNavigationRuleType_navigationRuleExtension_NavigationRuleExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateOrderingOrderingType_name_NameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateOrderingOrderingType_name_NameType.gif
deleted file mode 100644
index 9641c51..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateOrderingOrderingType_name_NameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateOrderingOrderingType_others_OrderingOthersType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateOrderingOrderingType_others_OrderingOthersType.gif
deleted file mode 100644
index 6ec7dad..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateOrderingOrderingType_others_OrderingOthersType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateOrderingType_after_OrderingOrderingType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateOrderingType_after_OrderingOrderingType.gif
deleted file mode 100644
index efd089b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateOrderingType_after_OrderingOrderingType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateOrderingType_before_OrderingOrderingType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateOrderingType_before_OrderingOrderingType.gif
deleted file mode 100644
index efd089b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateOrderingType_before_OrderingOrderingType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_defaultValue_DefaultValueType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_defaultValue_DefaultValueType.gif
deleted file mode 100644
index ae8f059..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_defaultValue_DefaultValueType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_description_DescriptionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_description_DescriptionType.gif
deleted file mode 100644
index 527759b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_description_DescriptionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_displayName_DisplayNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_displayName_DisplayNameType.gif
deleted file mode 100644
index c7bd777..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_displayName_DisplayNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_icon_IconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_icon_IconType.gif
deleted file mode 100644
index ee73faa..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_icon_IconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_propertyClass_PropertyClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_propertyClass_PropertyClassType.gif
deleted file mode 100644
index 2ebeed2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_propertyClass_PropertyClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_propertyExtension_PropertyExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_propertyExtension_PropertyExtensionType.gif
deleted file mode 100644
index f9f81a4..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_propertyExtension_PropertyExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_propertyName_PropertyNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_propertyName_PropertyNameType.gif
deleted file mode 100644
index af55e8d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_propertyName_PropertyNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_suggestedValue_SuggestedValueType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_suggestedValue_SuggestedValueType.gif
deleted file mode 100644
index 8875a43..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreatePropertyType_suggestedValue_SuggestedValueType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRedirectType_viewParam_RedirectViewParamType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRedirectType_viewParam_RedirectViewParamType.gif
deleted file mode 100644
index 7d6e6bc..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRedirectType_viewParam_RedirectViewParamType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRedirectViewParamType_name_NameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRedirectViewParamType_name_NameType.gif
deleted file mode 100644
index 2f44cc3..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRedirectViewParamType_name_NameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRedirectViewParamType_value_ValueType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRedirectViewParamType_value_ValueType.gif
deleted file mode 100644
index ab37de2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRedirectViewParamType_value_ValueType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateReferencedBeanType_description_DescriptionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateReferencedBeanType_description_DescriptionType.gif
deleted file mode 100644
index fe734c7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateReferencedBeanType_description_DescriptionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateReferencedBeanType_displayName_DisplayNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateReferencedBeanType_displayName_DisplayNameType.gif
deleted file mode 100644
index 8d3a8e0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateReferencedBeanType_displayName_DisplayNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateReferencedBeanType_icon_IconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateReferencedBeanType_icon_IconType.gif
deleted file mode 100644
index b1bf686..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateReferencedBeanType_icon_IconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateReferencedBeanType_referencedBeanClass_ReferencedBeanClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateReferencedBeanType_referencedBeanClass_ReferencedBeanClassType.gif
deleted file mode 100644
index 5915315..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateReferencedBeanType_referencedBeanClass_ReferencedBeanClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateReferencedBeanType_referencedBeanName_ReferencedBeanNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateReferencedBeanType_referencedBeanName_ReferencedBeanNameType.gif
deleted file mode 100644
index ccfe115..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateReferencedBeanType_referencedBeanName_ReferencedBeanNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_clientBehaviorRenderer_ClientBehaviorRendererType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_clientBehaviorRenderer_ClientBehaviorRendererType.gif
deleted file mode 100644
index 1d747da..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_clientBehaviorRenderer_ClientBehaviorRendererType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_description_DescriptionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_description_DescriptionType.gif
deleted file mode 100644
index 2b77e50..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_description_DescriptionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_displayName_DisplayNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_displayName_DisplayNameType.gif
deleted file mode 100644
index 9f85940..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_displayName_DisplayNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_icon_IconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_icon_IconType.gif
deleted file mode 100644
index fe7b106..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_icon_IconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_renderKitClass_RenderKitClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_renderKitClass_RenderKitClassType.gif
deleted file mode 100644
index e4abad2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_renderKitClass_RenderKitClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_renderKitExtension_RenderKitExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_renderKitExtension_RenderKitExtensionType.gif
deleted file mode 100644
index dbd19ed..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_renderKitExtension_RenderKitExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_renderKitId_RenderKitIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_renderKitId_RenderKitIdType.gif
deleted file mode 100644
index 1bf7437..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_renderKitId_RenderKitIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_renderer_RendererType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_renderer_RendererType.gif
deleted file mode 100644
index d749f03..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRenderKitType_renderer_RendererType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_attribute_AttributeType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_attribute_AttributeType.gif
deleted file mode 100644
index 3be3f93..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_attribute_AttributeType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_componentFamily_ComponentFamilyType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_componentFamily_ComponentFamilyType.gif
deleted file mode 100644
index fa2e11c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_componentFamily_ComponentFamilyType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_description_DescriptionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_description_DescriptionType.gif
deleted file mode 100644
index 66a097b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_description_DescriptionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_displayName_DisplayNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_displayName_DisplayNameType.gif
deleted file mode 100644
index dd919f9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_displayName_DisplayNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_facet_FacetType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_facet_FacetType.gif
deleted file mode 100644
index 0091f17..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_facet_FacetType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_icon_IconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_icon_IconType.gif
deleted file mode 100644
index df2b32d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_icon_IconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_rendererClass_RendererClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_rendererClass_RendererClassType.gif
deleted file mode 100644
index 30dc32e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_rendererClass_RendererClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_rendererExtension_RendererExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_rendererExtension_RendererExtensionType.gif
deleted file mode 100644
index b021070..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_rendererExtension_RendererExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_rendererType_RendererTypeType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_rendererType_RendererTypeType.gif
deleted file mode 100644
index 6beaa5a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateRendererType_rendererType_RendererTypeType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateResourceBundleType_description_DescriptionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateResourceBundleType_description_DescriptionType.gif
deleted file mode 100644
index 66a097b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateResourceBundleType_description_DescriptionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateResourceBundleType_displayName_DisplayNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateResourceBundleType_displayName_DisplayNameType.gif
deleted file mode 100644
index dd919f9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateResourceBundleType_displayName_DisplayNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateResourceBundleType_icon_IconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateResourceBundleType_icon_IconType.gif
deleted file mode 100644
index df2b32d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateResourceBundleType_icon_IconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateSystemEventListenerType_sourceClass_SourceClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateSystemEventListenerType_sourceClass_SourceClassType.gif
deleted file mode 100644
index a9efa38..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateSystemEventListenerType_sourceClass_SourceClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateSystemEventListenerType_systemEventClass_SystemEventClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateSystemEventListenerType_systemEventClass_SystemEventClassType.gif
deleted file mode 100644
index dd4294c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateSystemEventListenerType_systemEventClass_SystemEventClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateSystemEventListenerType_systemEventListenerClass_SystemEventListenerClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateSystemEventListenerType_systemEventListenerClass_SystemEventListenerClassType.gif
deleted file mode 100644
index 0818bec..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateSystemEventListenerType_systemEventListenerClass_SystemEventListenerClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_attribute_AttributeType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_attribute_AttributeType.gif
deleted file mode 100644
index 647a6ff..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_attribute_AttributeType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_description_DescriptionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_description_DescriptionType.gif
deleted file mode 100644
index b913037..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_description_DescriptionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_displayName_DisplayNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_displayName_DisplayNameType.gif
deleted file mode 100644
index 23c1e15..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_displayName_DisplayNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_icon_IconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_icon_IconType.gif
deleted file mode 100644
index 46c6860..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_icon_IconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_property_PropertyType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_property_PropertyType.gif
deleted file mode 100644
index 1808567..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_property_PropertyType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_validatorClass_ValidatorClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_validatorClass_ValidatorClassType.gif
deleted file mode 100644
index d5d9efe..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_validatorClass_ValidatorClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_validatorExtension_ValidatorExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_validatorExtension_ValidatorExtensionType.gif
deleted file mode 100644
index 10a1ab5..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_validatorExtension_ValidatorExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_validatorId_ValidatorIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_validatorId_ValidatorIdType.gif
deleted file mode 100644
index 378c786..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/ctool16/CreateValidatorType_validatorId_ValidatorIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/AbsoluteOrderingType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/AbsoluteOrderingType.gif
deleted file mode 100644
index b2f5929..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/AbsoluteOrderingType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ActionListenerType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ActionListenerType.gif
deleted file mode 100644
index d3dc5a9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ActionListenerType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ApplicationExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ApplicationExtensionType.gif
deleted file mode 100644
index 7c2aaac..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ApplicationExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ApplicationFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ApplicationFactoryType.gif
deleted file mode 100644
index 53500da..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ApplicationFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ApplicationType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ApplicationType.gif
deleted file mode 100644
index ed87474..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ApplicationType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/AttributeClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/AttributeClassType.gif
deleted file mode 100644
index 498364f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/AttributeClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/AttributeExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/AttributeExtensionType.gif
deleted file mode 100644
index c00aedf..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/AttributeExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/AttributeNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/AttributeNameType.gif
deleted file mode 100644
index cb1755a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/AttributeNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/AttributeType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/AttributeType.gif
deleted file mode 100644
index 338fb8d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/AttributeType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/BaseNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/BaseNameType.gif
deleted file mode 100644
index d3dc5a9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/BaseNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/BehaviorClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/BehaviorClassType.gif
deleted file mode 100644
index 8f36206..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/BehaviorClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/BehaviorExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/BehaviorExtensionType.gif
deleted file mode 100644
index d51e409..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/BehaviorExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/BehaviorIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/BehaviorIdType.gif
deleted file mode 100644
index 5b40c4e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/BehaviorIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/BehaviorType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/BehaviorType.gif
deleted file mode 100644
index e74485f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/BehaviorType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ClientBehaviorRendererClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ClientBehaviorRendererClassType.gif
deleted file mode 100644
index ed1cbaf..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ClientBehaviorRendererClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ClientBehaviorRendererType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ClientBehaviorRendererType.gif
deleted file mode 100644
index ab31737..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ClientBehaviorRendererType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ClientBehaviorRendererTypeType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ClientBehaviorRendererTypeType.gif
deleted file mode 100644
index cf289c2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ClientBehaviorRendererTypeType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ComponentClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ComponentClassType.gif
deleted file mode 100644
index afb82ea..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ComponentClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ComponentExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ComponentExtensionType.gif
deleted file mode 100644
index 33a997a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ComponentExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ComponentFamilyType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ComponentFamilyType.gif
deleted file mode 100644
index caf2804..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ComponentFamilyType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ComponentType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ComponentType.gif
deleted file mode 100644
index 5a9bc75..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ComponentType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ComponentTypeType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ComponentTypeType.gif
deleted file mode 100644
index 8a5c70c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ComponentTypeType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ConverterClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ConverterClassType.gif
deleted file mode 100644
index 7bac4fd..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ConverterClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ConverterExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ConverterExtensionType.gif
deleted file mode 100644
index a26660e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ConverterExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ConverterForClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ConverterForClassType.gif
deleted file mode 100644
index a3908bc..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ConverterForClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ConverterIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ConverterIdType.gif
deleted file mode 100644
index 89ad5da..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ConverterIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ConverterType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ConverterType.gif
deleted file mode 100644
index 7c2aaac..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ConverterType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DefaultLocaleType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DefaultLocaleType.gif
deleted file mode 100644
index 98b351f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DefaultLocaleType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DefaultRenderKitIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DefaultRenderKitIdType.gif
deleted file mode 100644
index cdd3b76..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DefaultRenderKitIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DefaultValidatorsType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DefaultValidatorsType.gif
deleted file mode 100644
index c66ca45..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DefaultValidatorsType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DefaultValueType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DefaultValueType.gif
deleted file mode 100644
index 89ad5da..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DefaultValueType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DescriptionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DescriptionType.gif
deleted file mode 100644
index 53500da..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DescriptionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DisplayNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DisplayNameType.gif
deleted file mode 100644
index ea58a65..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DisplayNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DocumentRoot.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DocumentRoot.gif
deleted file mode 100644
index 739ebbf..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DocumentRoot.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DynamicAttribute.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DynamicAttribute.gif
deleted file mode 100644
index 420eee1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DynamicAttribute.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DynamicElement.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DynamicElement.gif
deleted file mode 100644
index 90d10f9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/DynamicElement.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ELResolverType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ELResolverType.gif
deleted file mode 100644
index 7b7c428..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ELResolverType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ExceptionHandlerFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ExceptionHandlerFactoryType.gif
deleted file mode 100644
index 4532576..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ExceptionHandlerFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ExternalContextFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ExternalContextFactoryType.gif
deleted file mode 100644
index 20f542c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ExternalContextFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfigExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfigExtensionType.gif
deleted file mode 100644
index 35ef84e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfigExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfigType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfigType.gif
deleted file mode 100644
index c4a8af4..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfigType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_ActionListener.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_ActionListener.gif
deleted file mode 100644
index 67b2d33..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_ActionListener.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_Application.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_Application.gif
deleted file mode 100644
index 57e5b1e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_Application.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_Component.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_Component.gif
deleted file mode 100644
index 347a8ff..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_Component.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_Converter.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_Converter.gif
deleted file mode 100644
index 16466ed..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_Converter.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_Factory.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_Factory.gif
deleted file mode 100644
index 955d5e8..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_Factory.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_LifeCycle.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_LifeCycle.gif
deleted file mode 100644
index 2c15d64..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_LifeCycle.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_LocaleConfig.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_LocaleConfig.gif
deleted file mode 100644
index 596f68b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_LocaleConfig.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_ManagedBean.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_ManagedBean.gif
deleted file mode 100644
index 6cdef7b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_ManagedBean.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_MessageBundle.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_MessageBundle.gif
deleted file mode 100644
index 8f40ee1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_MessageBundle.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_NavigationHandler.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_NavigationHandler.gif
deleted file mode 100644
index 0e242c7..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_NavigationHandler.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_Pageflow16.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_Pageflow16.gif
deleted file mode 100644
index 5ea67da..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_Pageflow16.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_PhaseListener.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_PhaseListener.gif
deleted file mode 100644
index e9e7238..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_PhaseListener.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_Plugin.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_Plugin.gif
deleted file mode 100644
index 5ea67da..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_Plugin.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_PropertyResolver.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_PropertyResolver.gif
deleted file mode 100644
index 39064d9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_PropertyResolver.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_RenderKit.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_RenderKit.gif
deleted file mode 100644
index 30ba00d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_RenderKit.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_StateManager.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_StateManager.gif
deleted file mode 100644
index bf3102c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_StateManager.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_Validator.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_Validator.gif
deleted file mode 100644
index 86196e9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_Validator.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_VariableResolver.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_VariableResolver.gif
deleted file mode 100644
index 642b874..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_VariableResolver.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_ViewHandler.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_ViewHandler.gif
deleted file mode 100644
index 4834c83..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesConfig_ViewHandler.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesContextFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesContextFactoryType.gif
deleted file mode 100644
index 420eee1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacesContextFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacetExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacetExtensionType.gif
deleted file mode 100644
index 83afb9b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacetExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacetNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacetNameType.gif
deleted file mode 100644
index 98b351f..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacetNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacetType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacetType.gif
deleted file mode 100644
index 136e3b2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FacetType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FactoryExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FactoryExtensionType.gif
deleted file mode 100644
index 90d10f9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FactoryExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FactoryType.gif
deleted file mode 100644
index 83afb9b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FromActionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FromActionType.gif
deleted file mode 100644
index b3643da..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FromActionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FromOutcomeType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FromOutcomeType.gif
deleted file mode 100644
index a26660e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FromOutcomeType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FromViewIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FromViewIdType.gif
deleted file mode 100644
index 48e3cf2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/FromViewIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/IconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/IconType.gif
deleted file mode 100644
index 106881e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/IconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/IfType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/IfType.gif
deleted file mode 100644
index fd14cea..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/IfType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/KeyClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/KeyClassType.gif
deleted file mode 100644
index 35ef84e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/KeyClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/KeyType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/KeyType.gif
deleted file mode 100644
index 136e3b2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/KeyType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/LargeIconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/LargeIconType.gif
deleted file mode 100644
index 33a997a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/LargeIconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/LifecycleExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/LifecycleExtensionType.gif
deleted file mode 100644
index 05dc74a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/LifecycleExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/LifecycleFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/LifecycleFactoryType.gif
deleted file mode 100644
index 7bac4fd..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/LifecycleFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/LifecycleType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/LifecycleType.gif
deleted file mode 100644
index 90d10f9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/LifecycleType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ListEntriesType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ListEntriesType.gif
deleted file mode 100644
index 48e3cf2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ListEntriesType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/LocaleConfigType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/LocaleConfigType.gif
deleted file mode 100644
index 30f0c48..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/LocaleConfigType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ManagedBeanClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ManagedBeanClassType.gif
deleted file mode 100644
index 05dc74a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ManagedBeanClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ManagedBeanExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ManagedBeanExtensionType.gif
deleted file mode 100644
index 8a5c70c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ManagedBeanExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ManagedBeanNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ManagedBeanNameType.gif
deleted file mode 100644
index 5a9bc75..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ManagedBeanNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ManagedBeanScopeType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ManagedBeanScopeType.gif
deleted file mode 100644
index 83afb9b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ManagedBeanScopeType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ManagedBeanType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ManagedBeanType.gif
deleted file mode 100644
index 5915591..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ManagedBeanType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ManagedPropertyType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ManagedPropertyType.gif
deleted file mode 100644
index 14af8aa..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ManagedPropertyType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/MapEntriesType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/MapEntriesType.gif
deleted file mode 100644
index afb82ea..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/MapEntriesType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/MapEntryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/MapEntryType.gif
deleted file mode 100644
index 53500da..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/MapEntryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/MessageBundleType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/MessageBundleType.gif
deleted file mode 100644
index 89ad5da..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/MessageBundleType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/NameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/NameType.gif
deleted file mode 100644
index e565a0b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/NameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/NavigationCaseType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/NavigationCaseType.gif
deleted file mode 100644
index c4a8af4..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/NavigationCaseType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/NavigationHandlerType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/NavigationHandlerType.gif
deleted file mode 100644
index 94c953e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/NavigationHandlerType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/NavigationRuleExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/NavigationRuleExtensionType.gif
deleted file mode 100644
index c673a52..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/NavigationRuleExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/NavigationRuleType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/NavigationRuleType.gif
deleted file mode 100644
index db7414e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/NavigationRuleType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/NullValueType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/NullValueType.gif
deleted file mode 100644
index c673a52..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/NullValueType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/OrderingOrderingType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/OrderingOrderingType.gif
deleted file mode 100644
index bc30f71..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/OrderingOrderingType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/OrderingOthersType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/OrderingOthersType.gif
deleted file mode 100644
index c3a5769..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/OrderingOthersType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/OrderingType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/OrderingType.gif
deleted file mode 100644
index 0a8a1a6..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/OrderingType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PartialTraversalType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PartialTraversalType.gif
deleted file mode 100644
index c66ca45..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PartialTraversalType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PartialViewContextFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PartialViewContextFactoryType.gif
deleted file mode 100644
index cb04c3e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PartialViewContextFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PhaseListenerType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PhaseListenerType.gif
deleted file mode 100644
index 7b7c428..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PhaseListenerType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PropertyClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PropertyClassType.gif
deleted file mode 100644
index caf2804..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PropertyClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PropertyExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PropertyExtensionType.gif
deleted file mode 100644
index 420eee1..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PropertyExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PropertyNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PropertyNameType.gif
deleted file mode 100644
index 83afb9b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PropertyNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PropertyResolverType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PropertyResolverType.gif
deleted file mode 100644
index c00aedf..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PropertyResolverType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PropertyType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PropertyType.gif
deleted file mode 100644
index e4b530e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/PropertyType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RedirectType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RedirectType.gif
deleted file mode 100644
index 30f0c48..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RedirectType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RedirectViewParamType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RedirectViewParamType.gif
deleted file mode 100644
index d972a2b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RedirectViewParamType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ReferencedBeanClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ReferencedBeanClassType.gif
deleted file mode 100644
index 45731fe..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ReferencedBeanClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ReferencedBeanNameType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ReferencedBeanNameType.gif
deleted file mode 100644
index e4bc22d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ReferencedBeanNameType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ReferencedBeanType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ReferencedBeanType.gif
deleted file mode 100644
index c673a52..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ReferencedBeanType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RenderKitClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RenderKitClassType.gif
deleted file mode 100644
index 2124f3e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RenderKitClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RenderKitExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RenderKitExtensionType.gif
deleted file mode 100644
index 7b7c428..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RenderKitExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RenderKitFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RenderKitFactoryType.gif
deleted file mode 100644
index c673a52..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RenderKitFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RenderKitIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RenderKitIdType.gif
deleted file mode 100644
index 7c2aaac..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RenderKitIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RenderKitType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RenderKitType.gif
deleted file mode 100644
index 9041598..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RenderKitType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RendererClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RendererClassType.gif
deleted file mode 100644
index 35ef84e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RendererClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RendererExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RendererExtensionType.gif
deleted file mode 100644
index 83afb9b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RendererExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RendererType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RendererType.gif
deleted file mode 100644
index 136e3b2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RendererType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RendererTypeType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RendererTypeType.gif
deleted file mode 100644
index e4b530e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/RendererTypeType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ResourceBundleType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ResourceBundleType.gif
deleted file mode 100644
index 136e3b2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ResourceBundleType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ResourceHandlerType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ResourceHandlerType.gif
deleted file mode 100644
index cc16827..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ResourceHandlerType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/SmallIconType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/SmallIconType.gif
deleted file mode 100644
index b1f8afa..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/SmallIconType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/SourceClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/SourceClassType.gif
deleted file mode 100644
index 841f225..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/SourceClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/StateManagerType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/StateManagerType.gif
deleted file mode 100644
index e4bc22d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/StateManagerType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/SuggestedValueType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/SuggestedValueType.gif
deleted file mode 100644
index db7414e..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/SuggestedValueType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/SupportedLocaleType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/SupportedLocaleType.gif
deleted file mode 100644
index 89ad5da..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/SupportedLocaleType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/SystemEventClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/SystemEventClassType.gif
deleted file mode 100644
index 4532576..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/SystemEventClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/SystemEventListenerClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/SystemEventListenerClassType.gif
deleted file mode 100644
index d972a2b..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/SystemEventListenerClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/SystemEventListenerType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/SystemEventListenerType.gif
deleted file mode 100644
index b2f5929..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/SystemEventListenerType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/TagHandlerDelegateFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/TagHandlerDelegateFactoryType.gif
deleted file mode 100644
index eb42c23..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/TagHandlerDelegateFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ToViewIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ToViewIdType.gif
deleted file mode 100644
index e4bc22d..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ToViewIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ValidatorClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ValidatorClassType.gif
deleted file mode 100644
index 05dc74a..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ValidatorClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ValidatorExtensionType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ValidatorExtensionType.gif
deleted file mode 100644
index 8a5c70c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ValidatorExtensionType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ValidatorIdType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ValidatorIdType.gif
deleted file mode 100644
index d92f34c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ValidatorIdType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ValidatorType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ValidatorType.gif
deleted file mode 100644
index 5915591..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ValidatorType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ValueClassType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ValueClassType.gif
deleted file mode 100644
index d3dc5a9..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ValueClassType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ValueType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ValueType.gif
deleted file mode 100644
index badaab0..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ValueType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/VarType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/VarType.gif
deleted file mode 100644
index 136e3b2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/VarType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/VariableResolverType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/VariableResolverType.gif
deleted file mode 100644
index a3908bc..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/VariableResolverType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ViewDeclarationLanguageFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ViewDeclarationLanguageFactoryType.gif
deleted file mode 100644
index 12208c2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ViewDeclarationLanguageFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ViewHandlerType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ViewHandlerType.gif
deleted file mode 100644
index 2b69256..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/ViewHandlerType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/VisitContextFactoryType.gif b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/VisitContextFactoryType.gif
deleted file mode 100644
index e277e7c..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/icons/full/obj16/VisitContextFactoryType.gif
+++ /dev/null
Binary files differ
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/model/FacesConfig.ecore b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/model/FacesConfig.ecore
deleted file mode 100644
index dda6b72..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/model/FacesConfig.ecore
+++ /dev/null
@@ -1,4828 +0,0 @@
-<?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="facesconfig"
-    nsURI="http://www.eclipse.org/webtools/jsf/schema/facesconfig.xsd" nsPrefix="facesconfig">
-  <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-    <details key="documentation" value="&#xD;&#xA;   See http://www.w3.org/XML/1998/namespace.html and&#xD;&#xA;   http://www.w3.org/TR/REC-xml for information about this namespace.&#xD;&#xA;&#xD;&#xA;    This schema document describes the XML namespace, in a form&#xD;&#xA;    suitable for import by other schema documents.  &#xD;&#xA;&#xD;&#xA;    Note that local names in this namespace are intended to be defined&#xD;&#xA;    only by the World Wide Web Consortium or its subgroups.  The&#xD;&#xA;    following names are currently defined in this namespace and should&#xD;&#xA;    not be used with conflicting semantics by any Working Group,&#xD;&#xA;    specification, or document instance:&#xD;&#xA;&#xD;&#xA;    base (as an attribute name): denotes an attribute whose value&#xD;&#xA;         provides a URI to be used as the base for interpreting any&#xD;&#xA;         relative URIs in the scope of the element on which it&#xD;&#xA;         appears; its value is inherited.  This name is reserved&#xD;&#xA;         by virtue of its definition in the XML Base specification.&#xD;&#xA;&#xD;&#xA;    id   (as an attribute name): denotes an attribute whose value&#xD;&#xA;         should be interpreted as if declared to be of type ID.&#xD;&#xA;         The xml:id specification is not yet a W3C Recommendation,&#xD;&#xA;         but this attribute is included here to facilitate experimentation&#xD;&#xA;         with the mechanisms it proposes.  Note that it is _not_ included&#xD;&#xA;         in the specialAttrs attribute group.&#xD;&#xA;&#xD;&#xA;    lang (as an attribute name): denotes an attribute whose value&#xD;&#xA;         is a language code for the natural language of the content of&#xD;&#xA;         any element; its value is inherited.  This name is reserved&#xD;&#xA;         by virtue of its definition in the XML specification.&#xD;&#xA;  &#xD;&#xA;    space (as an attribute name): denotes an attribute whose&#xD;&#xA;         value is a keyword indicating what whitespace processing&#xD;&#xA;         discipline is intended for the content of the element; its&#xD;&#xA;         value is inherited.  This name is reserved by virtue of its&#xD;&#xA;         definition in the XML specification.&#xD;&#xA;&#xD;&#xA;    Father (in any context at all): denotes Jon Bosak, the chair of &#xD;&#xA;         the original XML Working Group.  This name is reserved by &#xD;&#xA;         the following decision of the W3C XML Plenary and &#xD;&#xA;         XML Coordination groups:&#xD;&#xA;&#xD;&#xA;             In appreciation for his vision, leadership and dedication&#xD;&#xA;             the W3C XML Plenary on this 10th day of February, 2000&#xD;&#xA;             reserves for Jon Bosak in perpetuity the XML name&#xD;&#xA;             xml:Father&#xD;&#xA;  &#xD;&#xA;This schema defines attributes and an attribute group&#xD;&#xA;        suitable for use by&#xD;&#xA;        schemas wishing to allow xml:base, xml:lang, xml:space or xml:id&#xD;&#xA;        attributes on elements they define.&#xD;&#xA;&#xD;&#xA;        To enable this, such a schema must import this schema&#xD;&#xA;        for the XML namespace, e.g. as follows:&#xD;&#xA;        &amp;lt;schema . . .&amp;gt;&#xD;&#xA;         . . .&#xD;&#xA;         &amp;lt;import namespace=&quot;http://www.w3.org/XML/1998/namespace&quot;&#xD;&#xA;                    schemaLocation=&quot;http://www.w3.org/2001/xml.xsd&quot;/&amp;gt;&#xD;&#xA;&#xD;&#xA;        Subsequently, qualified reference to any of the attributes&#xD;&#xA;        or the group defined below will have the desired effect, e.g.&#xD;&#xA;&#xD;&#xA;        &amp;lt;type . . .&amp;gt;&#xD;&#xA;         . . .&#xD;&#xA;         &amp;lt;attributeGroup ref=&quot;xml:specialAttrs&quot;/&amp;gt;&#xD;&#xA; &#xD;&#xA;         will define a type which will schema-validate an instance&#xD;&#xA;         element with any of those attributes&#xD;&#xA;In keeping with the XML Schema WG's standard versioning&#xD;&#xA;   policy, this schema document will persist at&#xD;&#xA;   http://www.w3.org/2005/08/xml.xsd.&#xD;&#xA;   At the date of issue it can also be found at&#xD;&#xA;   http://www.w3.org/2001/xml.xsd.&#xD;&#xA;   The schema document at that URI may however change in the future,&#xD;&#xA;   in order to remain compatible with the latest version of XML Schema&#xD;&#xA;   itself, or with the XML namespace itself.  In other words, if the XML&#xD;&#xA;   Schema or XML namespaces change, the version of this document at&#xD;&#xA;   http://www.w3.org/2001/xml.xsd will change&#xD;&#xA;   accordingly; the version at&#xD;&#xA;   http://www.w3.org/2005/08/xml.xsd will not change.&#xD;&#xA;  "/>
-  </eAnnotations>
-  <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-    <details key="qualified" value="false"/>
-  </eAnnotations>
-  <eClassifiers xsi:type="ecore:EClass" name="AbsoluteOrderingType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="absolute-ordering_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="name" upperBound="-1" eType="#//NameType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="others" eType="#//OrderingOthersType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="others"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ActionListenerType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="action-listener_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ApplicationFactoryType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="application-factory_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ApplicationType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="application_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="actionListener" upperBound="-1"
-        eType="#//ActionListenerType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="action-listener"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="defaultRenderKitId" upperBound="-1"
-        eType="#//DefaultRenderKitIdType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="default-render-kit-id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="messageBundle" upperBound="-1"
-        eType="#//MessageBundleType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="message-bundle"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="navigationHandler" upperBound="-1"
-        eType="#//NavigationHandlerType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="navigation-handler"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="viewHandler" upperBound="-1"
-        eType="#//ViewHandlerType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="view-handler"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="stateManager" upperBound="-1"
-        eType="#//StateManagerType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="state-manager"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="eLResolver" upperBound="-1"
-        eType="#//ELResolverType">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="el-resolver"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="propertyResolver" upperBound="-1"
-        eType="#//PropertyResolverType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="property-resolver"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="variableResolver" upperBound="-1"
-        eType="#//VariableResolverType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="variable-resolver"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="resourceHandler" upperBound="-1"
-        eType="#//ResourceHandlerType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="resource-handler"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="systemEventListener" upperBound="-1"
-        eType="#//SystemEventListenerType">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="system-event-listener"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="localeConfig" upperBound="-1"
-        eType="#//LocaleConfigType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="locale-config"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="resourceBundle" upperBound="-1"
-        eType="#//ResourceBundleType">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="resource-bundle"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="applicationExtension" upperBound="-1"
-        eType="#//ApplicationExtensionType">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="application-extension"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="defaultValidators" upperBound="-1"
-        eType="#//DefaultValidatorsType">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="default-validators"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ApplicationExtensionType" eSuperTypes="#//ExtensionType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="application-extension_._type"/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="AttributeClassType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="attribute-class_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="AttributeExtensionType" eSuperTypes="#//ExtensionType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="attribute-extension_._type"/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="AttributeNameType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="attribute-name_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="AttributeType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="attribute_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="description" upperBound="-1"
-        eType="#//DescriptionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="description"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="displayName" upperBound="-1"
-        eType="#//DisplayNameType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="display-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="icon" upperBound="-1" eType="#//IconType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="icon"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="attributeName" lowerBound="1"
-        eType="#//AttributeNameType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="attribute-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="attributeClass" lowerBound="1"
-        eType="#//AttributeClassType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="attribute-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="defaultValue" eType="#//DefaultValueType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="default-value"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="suggestedValue" eType="#//SuggestedValueType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="suggested-value"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="attributeExtension" upperBound="-1"
-        eType="#//AttributeExtensionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="attribute-extension"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="BehaviorClassType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="behavior-class_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="BehaviorIdType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="behavior-id_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="BehaviorType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="behavior_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="description" upperBound="-1"
-        eType="#//DescriptionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="description"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="displayName" upperBound="-1"
-        eType="#//DisplayNameType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="display-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="icon" upperBound="-1" eType="#//IconType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="icon"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="behaviorId" lowerBound="1"
-        eType="#//BehaviorIdType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="behavior-id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="behaviorClass" lowerBound="1"
-        eType="#//BehaviorClassType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="behavior-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="attribute" upperBound="-1"
-        eType="#//AttributeType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="attribute"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="property" upperBound="-1"
-        eType="#//PropertyType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="property"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="behaviorExtension" upperBound="-1"
-        eType="#//BehaviorExtensionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="behavior-extension"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="BehaviorExtensionType" eSuperTypes="#//ExtensionType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="behavior-extension_._type"/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ClientBehaviorRendererClassType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="client-behavior-renderer-class_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ClientBehaviorRendererType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="client-behavior-renderer_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="clientBehaviorRendererType"
-        lowerBound="1" eType="#//ClientBehaviorRendererTypeType" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="client-behavior-renderer-type"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="clientBehaviorRendererClass"
-        lowerBound="1" eType="#//ClientBehaviorRendererClassType" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="client-behavior-renderer-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ClientBehaviorRendererTypeType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="client-behavior-renderer-type_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ComponentClassType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="component-class_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ComponentExtensionType" eSuperTypes="#//ExtensionType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="component-extension_._type"/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ComponentFamilyType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="component-family_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ComponentType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="component_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="description" upperBound="-1"
-        eType="#//DescriptionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="description"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="displayName" upperBound="-1"
-        eType="#//DisplayNameType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="display-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="icon" upperBound="-1" eType="#//IconType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="icon"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="componentType" lowerBound="1"
-        eType="#//ComponentTypeType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="component-type"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="componentClass" lowerBound="1"
-        eType="#//ComponentClassType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="component-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="facet" upperBound="-1"
-        eType="#//FacetType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="facet"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="attribute" upperBound="-1"
-        eType="#//AttributeType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="attribute"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="property" upperBound="-1"
-        eType="#//PropertyType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="property"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="componentExtension" upperBound="-1"
-        eType="#//ComponentExtensionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="component-extension"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ComponentTypeType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="component-type_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ConverterClassType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="converter-class_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ConverterForClassType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="converter-for-class_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ConverterIdType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="converter-id_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ConverterType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="converter_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="description" upperBound="-1"
-        eType="#//DescriptionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="description"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="displayName" upperBound="-1"
-        eType="#//DisplayNameType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="display-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="icon" upperBound="-1" eType="#//IconType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="icon"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="converterId" eType="#//ConverterIdType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="converter-id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="converterForClass" eType="#//ConverterForClassType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="converter-for-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="converterClass" lowerBound="1"
-        eType="#//ConverterClassType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="converter-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="attribute" upperBound="-1"
-        eType="#//AttributeType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="attribute"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="property" upperBound="-1"
-        eType="#//PropertyType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="property"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="converterExtension" upperBound="-1"
-        eType="#//ConverterExtensionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="converter-extension"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ConverterExtensionType" eSuperTypes="#//ExtensionType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="converter-extension_._type"/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="DefaultLocaleType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="default-locale_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="DefaultRenderKitIdType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="default-render-kit-id_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="DefaultValidatorsType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="default-validators_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="validatorId" upperBound="-1"
-        eType="#//ValidatorIdType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="validator-id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="DefaultValueType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="default-value_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="DescriptionType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="description_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="lang" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//Language">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="lang"/>
-        <details key="namespace" value="http://www.w3.org/XML/1998/namespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="DisplayNameType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="display-name_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="lang" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//Language">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="lang"/>
-        <details key="namespace" value="http://www.w3.org/XML/1998/namespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="DocumentRoot">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value=""/>
-      <details key="kind" value="mixed"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="mixed" unique="false" upperBound="-1"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EFeatureMapEntry">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="elementWildcard"/>
-        <details key="name" value=":mixed"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="xMLNSPrefixMap" unique="false"
-        upperBound="-1" eType="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EStringToStringMapEntry"
-        transient="true" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="xmlns:prefix"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="xSISchemaLocation" unique="false"
-        upperBound="-1" eType="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EStringToStringMapEntry"
-        transient="true" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="xsi:schemaLocation"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="absoluteOrdering" upperBound="-2"
-        eType="#//AbsoluteOrderingType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="absolute-ordering"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="actionListener" upperBound="-2"
-        eType="#//ActionListenerType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=" ==================== Subordinate&#xD;&#xA;                Elements ============================       The&#xD;&#xA;                &quot;action-listener&quot; element contains the fully&#xD;&#xA;                qualified class name     of the concrete ActionListener&#xD;&#xA;                implementation class that will be called     during the&#xD;&#xA;                Invoke Application phase of the request processing&#xD;&#xA;                lifecycle.     It must be of type &quot;ClassName&quot;. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="action-listener"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="application" upperBound="-2"
-        eType="#//ApplicationType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=" ==================== Definition Elements&#xD;&#xA;                =============================       The&#xD;&#xA;                &quot;application&quot; element provides a mechanism to&#xD;&#xA;                define the various     per-application-singleton&#xD;&#xA;                implementation classes for a particular web&#xD;&#xA;                application that is utilizing JavaServer Faces.  For&#xD;&#xA;                nested elements     that are not specified, the JSF&#xD;&#xA;                implementation must provide a suitable     default. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="application"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="applicationFactory" upperBound="-2"
-        eType="#//ApplicationFactoryType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;application-factory&quot;&#xD;&#xA;                element contains the fully qualified class     name of&#xD;&#xA;                the concrete ApplicationFactory implementation class&#xD;&#xA;                that     will be called when&#xD;&#xA;                FactoryFinder.getFactory(APPLICATION_FACTORY) is&#xD;&#xA;                called. It must be of type &quot;ClassName&quot;. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="application-factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="attribute" upperBound="-2"
-        eType="#//AttributeType" volatile="true" transient="true" derived="true" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;attribute&quot; element&#xD;&#xA;                represents a named, typed, value associated with     the&#xD;&#xA;                parent UIComponent via the generic attributes mechanism.&#xD;&#xA;                Attribute names must be unique within the scope of the&#xD;&#xA;                parent (or related)     component. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="attribute"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="attributeClass" upperBound="-2"
-        eType="#//AttributeClassType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;attribute-class&quot; element represents the Java type of the value&#xA;    associated with this attribute name.  It must be of type &quot;ClassName&quot;."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="attribute-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="attributeExtension" upperBound="-2"
-        eType="#//AttributeExtensionType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="      Extension element for attribute.&#xD;&#xA;                May contain implementation     specific content. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="attribute-extension"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="attributeName" upperBound="-2"
-        eType="#//AttributeNameType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;attribute-name&quot;&#xD;&#xA;                element represents the name under which the&#xD;&#xA;                corresponding value will be stored, in the generic&#xD;&#xA;                attributes of the     UIComponent we are related to. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="attribute-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="behavior" upperBound="-2"
-        eType="#//BehaviorType" volatile="true" transient="true" derived="true" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="behavior"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="behaviorClass" upperBound="-2"
-        eType="#//BehaviorClassType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="behavior-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="behaviorId" upperBound="-2"
-        eType="#//BehaviorIdType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="behavior-id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="behaviorExtension" upperBound="-2"
-        eType="#//BehaviorExtensionType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="behavior-extension"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="component" upperBound="-2"
-        eType="#//ComponentType" volatile="true" transient="true" derived="true" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;component&quot; element&#xD;&#xA;                represents a concrete UIComponent implementation&#xD;&#xA;                class that should be registered under the specified type&#xD;&#xA;                identifier,     along with its associated properties and&#xD;&#xA;                attributes.  Component types must     be unique within&#xD;&#xA;                the entire web application.      Nested&#xD;&#xA;                &quot;attribute&quot; elements identify generic&#xD;&#xA;                attributes that are recognized     by the implementation&#xD;&#xA;                logic of this component.  Nested &quot;property&quot;&#xD;&#xA;                elements     identify JavaBeans properties of the&#xD;&#xA;                component class that may be exposed     for manipulation&#xD;&#xA;                via tools. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="component"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="componentClass" upperBound="-2"
-        eType="#//ComponentClassType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;component-class&quot;&#xD;&#xA;                element represents the fully qualified class name     of&#xD;&#xA;                a concrete UIComponent implementation class.  It must be&#xD;&#xA;                of     type &quot;ClassName&quot;. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="component-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="componentExtension" upperBound="-2"
-        eType="#//ComponentExtensionType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="      Extension element for component.&#xD;&#xA;                May contain implementation     specific content. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="component-extension"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="componentFamily" upperBound="-2"
-        eType="#//ComponentFamilyType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;component-family&quot; element represents the component family for&#xA;    which the Renderer represented by the parent &quot;renderer&quot; element will be&#xA;    used."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="component-family"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="componentType" upperBound="-2"
-        eType="#//ComponentTypeType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;component-type&quot;&#xD;&#xA;                element represents the name under which the&#xD;&#xA;                corresponding UIComponent class should be registered. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="component-type"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="converter" upperBound="-2"
-        eType="#//ConverterType" volatile="true" transient="true" derived="true" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;converter&quot; element&#xD;&#xA;                represents a concrete Converter implementation     class&#xD;&#xA;                that should be registered under the specified converter&#xD;&#xA;                identifier.     Converter identifiers must be unique&#xD;&#xA;                within the entire web application.      Nested&#xD;&#xA;                &quot;attribute&quot; elements identify generic&#xD;&#xA;                attributes that may be     configured on the&#xD;&#xA;                corresponding UIComponent in order to affect the&#xD;&#xA;                operation of the Converter.  Nested &quot;property&quot;&#xD;&#xA;                elements identify JavaBeans     properties of the&#xD;&#xA;                Converter implementation class that may be configured&#xD;&#xA;                to affect the operation of the Converter. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="converter"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="converterClass" upperBound="-2"
-        eType="#//ConverterClassType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;converter-class&quot; element represents the fully qualified class name&#xA;    of a concrete Converter implementation class.  It must be of&#xA;    type &quot;ClassName&quot;."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="converter-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="converterForClass" upperBound="-2"
-        eType="#//ConverterForClassType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;converter-for-class&quot; element represents the fully qualified class name&#xA;    for which a Converter class will be registered.  It must be of&#xA;    type &quot;ClassName&quot;."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="converter-for-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="converterId" upperBound="-2"
-        eType="#//ConverterIdType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;converter-id&quot; element represents the identifier under which the&#xA;    corresponding Converter class should be registered."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="converter-id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="defaultLocale" upperBound="-2"
-        eType="#//DefaultLocaleType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="      The &quot;default-locale&quot;&#xD;&#xA;                element declares the default locale for this&#xD;&#xA;                application instance.  It must be specified as&#xD;&#xA;                :language:[_:country:[_:variant:]] without the colons,&#xD;&#xA;                for example      &quot;ja_JP_SJIS&quot;.  The separators&#xD;&#xA;                between the segments may be '-' or&#xD;&#xA;                '_'. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="default-locale"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="defaultRenderKitId" upperBound="-2"
-        eType="#//DefaultRenderKitIdType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;default-render-kit-id&quot; element allows the application to define&#xA;    a renderkit to be used other than the standard one. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="default-render-kit-id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="defaultValidators" upperBound="-2"
-        eType="#//DefaultValidatorsType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="default-validators"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="defaultValue" upperBound="-2"
-        eType="#//DefaultValueType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;default-value&quot; contains the value for the property or attribute&#xA;    in which this element resides.  This value differs from the&#xA;    &quot;suggested-value&quot; in that the property or attribute must take the&#xA;    value, whereas in &quot;suggested-value&quot; taking the value is optional."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="default-value"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="description" upperBound="-2"
-        eType="#//DescriptionType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;description&quot; element&#xD;&#xA;                contains a textual description of the element     it is&#xD;&#xA;                nested in, optionally flagged with a language code using&#xD;&#xA;                the     &quot;xml:lang&quot; attribute. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="description"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="displayName" upperBound="-2"
-        eType="#//DisplayNameType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;display-name&quot; element&#xD;&#xA;                is a short descriptive name describing the     entity&#xD;&#xA;                associated with the element it is nested in, intended to&#xD;&#xA;                be     displayed by tools, and optionally flagged with a&#xD;&#xA;                language code using     the &quot;xml:lang&quot;&#xD;&#xA;                attribute. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="display-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="exceptionHandlerFactory"
-        upperBound="-2" eType="#//ExceptionHandlerFactoryType" volatile="true" transient="true"
-        derived="true" containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="exception-handler-factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="externalContextFactory"
-        upperBound="-2" eType="#//ExternalContextFactoryType" volatile="true" transient="true"
-        derived="true" containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="external-context-factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="facesConfig" upperBound="-2"
-        eType="#//FacesConfigType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=" ==================== Top Level Elements&#xD;&#xA;                ==============================       The&#xD;&#xA;                &quot;faces-config&quot; element is the root of the&#xD;&#xA;                configuration information     hierarchy, and contains&#xD;&#xA;                nested elements for all of the other configuration&#xD;&#xA;                settings. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="faces-config"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="facesContextFactory" upperBound="-2"
-        eType="#//FacesContextFactoryType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The&#xD;&#xA;                &quot;faces-context-factory&quot; element contains the&#xD;&#xA;                fully qualified     class name of the concrete&#xD;&#xA;                FacesContextFactory implementation class     that will&#xD;&#xA;                be called when&#xD;&#xA;                FactoryFinder.getFactory(FACES_CONTEXT_FACTORY) is&#xD;&#xA;                called. It must     be of type &quot;ClassName&quot;. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="faces-context-factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="facet" upperBound="-2"
-        eType="#//FacetType" volatile="true" transient="true" derived="true" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="   Define the name and other design-time information for a facet that is&#xA;   associated with a renderer or a component."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="facet"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="facetExtension" upperBound="-2"
-        eType="#//FacetExtensionType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    Extension element for facet.  May contain implementation&#xA;    specific content."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="facet-extension"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="facetName" upperBound="-2"
-        eType="#//FacetNameType" volatile="true" transient="true" derived="true" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;facet-name&quot; element represents the facet name under which a&#xA;    UIComponent will be added to its parent.  It must be of type&#xA;    &quot;Identifier&quot;."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="facet-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="factory" upperBound="-2"
-        eType="#//FactoryType" volatile="true" transient="true" derived="true" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;factory&quot; element&#xD;&#xA;                provides a mechanism to define the various     Factories&#xD;&#xA;                that comprise parts of the implementation of JavaServer&#xD;&#xA;                Faces.  For nested elements that are not specified, the&#xD;&#xA;                JSF     implementation must provide a suitable default. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="fromAction" upperBound="-2"
-        eType="#//FromActionType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;from-action&quot; element contains an action reference expression&#xA;    that must have been executed (by the default ActionListener for handling&#xA;    application level events) in order to select this navigation rule.  If&#xA;    not specified, this rule will be relevant no matter which action reference&#xA;    was executed (or if no action reference was executed).&#xA;&#xA;    This value must be of type &quot;Action&quot;."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="from-action"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="fromOutcome" upperBound="-2"
-        eType="#//FromOutcomeType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;from-outcome&quot; element contains a logical outcome string returned&#xA;    by the execution of an application action method selected via an&#xA;    &quot;actionRef&quot; property (or a literal value specified by an &quot;action&quot;&#xA;    property) of a UICommand component.  If specified, this rule will be&#xA;    relevant only if the outcome value matches this element's value.  If&#xA;    not specified, this rule will be relevant no matter what the outcome&#xA;    value was."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="from-outcome"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="fromViewId" upperBound="-2"
-        eType="#//FromViewIdType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;from-view-id&quot; element contains the view identifier of the view&#xA;    for which the containing navigation rule is relevant.  If no&#xA;    &quot;from-view&quot; element is specified, this rule applies to navigation&#xA;    decisions on all views.  If this element is not specified, a value&#xA;    of &quot;*&quot; is assumed, meaning that this navigation rule applies to all&#xA;    views.&#xA;&#xA;    This value must be of type &quot;ViewIdPattern&quot;."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="from-view-id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="icon" upperBound="-2" eType="#//IconType"
-        volatile="true" transient="true" derived="true" containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;icon&quot; element&#xD;&#xA;                contains &quot;small-icon&quot; and&#xD;&#xA;                &quot;large-icon&quot; elements that     specify the&#xD;&#xA;                resoruce paths for small and large GIF or JPG icon&#xD;&#xA;                images     used to represent the parent element in a GUI&#xD;&#xA;                tool. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="icon"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="if" upperBound="-2" eType="#//IfType"
-        volatile="true" transient="true" derived="true" containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="if"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="key" upperBound="-2" eType="#//KeyType"
-        volatile="true" transient="true" derived="true" containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;key&quot; element is the String representation of a map key that&#xA;    will be stored in a managed property of type java.util.Map.  "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="key"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="keyClass" upperBound="-2"
-        eType="#//KeyClassType" volatile="true" transient="true" derived="true" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;key-class&quot; element defines the Java type to which each &quot;key&quot;&#xA;    element in a set of &quot;map-entry&quot; elements will be converted to.  It&#xA;    must be of type &quot;ClassName&quot;.  If omitted, &quot;java.lang.String&quot;&#xA;    is assumed."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="key-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="largeIcon" upperBound="-2"
-        eType="#//LargeIconType" volatile="true" transient="true" derived="true" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;large-icon&quot; element contains the resource path to a large (32x32)&#xA;    icon image.  The image may be in either GIF or JPG format."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="large-icon"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="lifecycle" upperBound="-2"
-        eType="#//LifecycleType" volatile="true" transient="true" derived="true" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;lifecycle&quot; element&#xD;&#xA;                provides a mechanism to specify     modifications to the&#xD;&#xA;                behaviour of the default Lifecycle     implementation&#xD;&#xA;                for this web application. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="lifecycle"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="lifecycleFactory" upperBound="-2"
-        eType="#//LifecycleFactoryType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;lifecycle-factory&quot;&#xD;&#xA;                element contains the fully qualified class name     of&#xD;&#xA;                the concrete LifecycleFactory implementation class that&#xD;&#xA;                will be called     when&#xD;&#xA;                FactoryFinder.getFactory(LIFECYCLE_FACTORY) is called.&#xD;&#xA;                It must be      of type &quot;ClassName&quot;. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="lifecycle-factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="listEntries" upperBound="-2"
-        eType="#//ListEntriesType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;list-entries&quot; element&#xD;&#xA;                represents a set of initialization     elements for a&#xD;&#xA;                managed property that is a java.util.List or an&#xD;&#xA;                array.  In the former case, the &quot;value-class&quot;&#xD;&#xA;                element can optionally     be used to declare the Java&#xD;&#xA;                type to which each value should be     converted before&#xD;&#xA;                adding it to the Collection. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="list-entries"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="localeConfig" upperBound="-2"
-        eType="#//LocaleConfigType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="      The &quot;locale-config&quot;&#xD;&#xA;                element allows the app developer to declare the&#xD;&#xA;                supported locales for this application.   "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="locale-config"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="managedBean" upperBound="-2"
-        eType="#//ManagedBeanType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;managed-bean&quot; element&#xD;&#xA;                represents a JavaBean, of a particular class,     that&#xD;&#xA;                will be dynamically instantiated at runtime (by the&#xD;&#xA;                default     VariableResolver implementation) if it is&#xD;&#xA;                referenced as the first element     of a value reference&#xD;&#xA;                expression, and no corresponding bean can be&#xD;&#xA;                identified in any scope.  In addition to the creation of&#xD;&#xA;                the managed bean,     and the optional storing of it&#xD;&#xA;                into the specified scope, the nested&#xD;&#xA;                managed-property elements can be used to initialize the&#xD;&#xA;                contents of     settable JavaBeans properties of the&#xD;&#xA;                created instance. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="managed-bean"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="managedBeanClass" upperBound="-2"
-        eType="#//ManagedBeanClassType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;managed-bean-class&quot; element represents the fully qualified class&#xA;    name of the Java class that will be used to instantiate a new instance&#xA;    if creation of the specified managed bean is requested.  It must be of&#xA;    type &quot;ClassName&quot;.&#xA;&#xA;    The specified class must conform to standard JavaBeans conventions.&#xA;    In particular, it must have a public zero-arguments constructor, and&#xA;    zero or more public property setters."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="managed-bean-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="managedBeanName" upperBound="-2"
-        eType="#//ManagedBeanNameType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;managed-bean-name&quot; element represents the attribute name under&#xA;    which a managed bean will be searched for, as well as stored (unless&#xA;    the &quot;managed-bean-scope&quot; value is &quot;none&quot;).  It must be of type&#xA;    &quot;Identifier&quot;."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="managed-bean-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="managedBeanScope" upperBound="-2"
-        eType="#//ManagedBeanScopeType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;managed-bean-scope&quot; element represents the scope into which a newly&#xA;    created instance of the specified managed bean will be stored (unless&#xA;    the value is &quot;none&quot;).  It must be of type &quot;ScopeOrNone&quot;."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="managed-bean-scope"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="managedProperty" upperBound="-2"
-        eType="#//ManagedPropertyType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;managed-property&quot;&#xD;&#xA;                element represents an individual property of a&#xD;&#xA;                managed bean that will be configured to the specified&#xD;&#xA;                value (or value set)     if the corresponding managed&#xD;&#xA;                bean is automatically created. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="managed-property"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="mapEntries" upperBound="-2"
-        eType="#//MapEntriesType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;map-entries' element&#xD;&#xA;                represents a set of key-entry pairs that     will be&#xD;&#xA;                added to the computed value of a managed property of&#xD;&#xA;                type     java.util.Map.  In addition, the Java class&#xD;&#xA;                types of the key and entry     values may be optionally&#xD;&#xA;                declared. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="map-entries"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="mapEntry" upperBound="-2"
-        eType="#//MapEntryType" volatile="true" transient="true" derived="true" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;map-entry&quot; element&#xD;&#xA;                reprsents a single key-entry pair that     will be added&#xD;&#xA;                to the computed value of a managed property of type&#xD;&#xA;                java.util.Map. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="map-entry"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="messageBundle" upperBound="-2"
-        eType="#//MessageBundleType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The base name of a resource bundle&#xD;&#xA;                representing the message resources     for this&#xD;&#xA;                application.  See the JavaDocs for the&#xD;&#xA;                &quot;java.util.ResourceBundle&quot;     class for more&#xD;&#xA;                information on the syntax of resource bundle names. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="message-bundle"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="name" upperBound="-2" eType="#//NameType"
-        volatile="true" transient="true" derived="true" containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="navigationCase" upperBound="-2"
-        eType="#//NavigationCaseType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;navigation-case&quot;&#xD;&#xA;                element describes a particular combination of&#xD;&#xA;                conditions that must match for this case to be executed,&#xD;&#xA;                and the     view id of the component tree that should be&#xD;&#xA;                selected next. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="navigation-case"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="navigationHandler" upperBound="-2"
-        eType="#//NavigationHandlerType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;navigation-handler&quot;&#xD;&#xA;                element contains the fully qualified class name     of&#xD;&#xA;                the concrete NavigationHandler implementation class that&#xD;&#xA;                will be called     during the Invoke Application phase&#xD;&#xA;                of the request processing lifecycle,     if the default&#xD;&#xA;                ActionListener (provided by the JSF implementation) is&#xD;&#xA;                used.     It must be of type &quot;ClassName&quot;. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="navigation-handler"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="navigationRule" upperBound="-2"
-        eType="#//NavigationRuleType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;navigation-rule&quot;&#xD;&#xA;                element represents an individual decision rule     that&#xD;&#xA;                will be utilized by the default NavigationHandler&#xD;&#xA;                implementation to make decisions on what view should be&#xD;&#xA;                displayed     next, based on the view id being&#xD;&#xA;                processed. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="navigation-rule"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="nullValue" upperBound="-2"
-        eType="#//NullValueType" volatile="true" transient="true" derived="true" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;null-value&quot; element&#xD;&#xA;                indicates that the managed property in which we     are&#xD;&#xA;                nested will be explicitly set to null if our managed&#xD;&#xA;                bean is     automatically created.  This is different&#xD;&#xA;                from omitting the managed     property element entirely,&#xD;&#xA;                which will cause no property setter to be     called for&#xD;&#xA;                this property.      The &quot;null-value&quot; element&#xD;&#xA;                can only be used when the associated&#xD;&#xA;                &quot;property-class&quot; identifies a Java class, not&#xD;&#xA;                a Java primitive. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="null-value"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="ordering" upperBound="-2"
-        eType="#//OrderingType" volatile="true" transient="true" derived="true" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="ordering"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="orderingOrdering" upperBound="-2"
-        eType="#//OrderingOrderingType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="ordering-ordering"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="others" upperBound="-2"
-        eType="#//OrderingOthersType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="others"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="partialViewContextFactory"
-        upperBound="-2" eType="#//PartialViewContextFactoryType" volatile="true" transient="true"
-        derived="true" containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="partial-view-context-factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="phaseListener" upperBound="-2"
-        eType="#//PhaseListenerType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=" The &quot;phase-listener&quot; element&#xD;&#xA;                contains the fully qualified class name of the concrete&#xD;&#xA;                PhaseListener implementation class that will be&#xD;&#xA;                registered on the Lifecycle. It must be of type&#xD;&#xA;                &quot;ClassName&quot;. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="phase-listener"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="property" upperBound="-2"
-        eType="#//PropertyType" volatile="true" transient="true" derived="true" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;property&quot; element&#xD;&#xA;                represents a JavaBean property of the Java class&#xD;&#xA;                represented by our parent element.      Property names&#xD;&#xA;                must be unique within the scope of the Java class&#xD;&#xA;                that is represented by the parent element, and must&#xD;&#xA;                correspond to     property names that will be recognized&#xD;&#xA;                when performing introspection     against that class via&#xD;&#xA;                java.beans.Introspector. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="property"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="propertyClass" upperBound="-2"
-        eType="#//PropertyClassType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;property-class&quot; element represents the Java type of the value&#xA;    associated with this property name.  It must be of type &quot;JavaType&quot;.&#xA;    If not specified, it can be inferred from existing classes; however,&#xA;    this element should be specified if the configuration file is going&#xA;    to be the source for generating the corresponding classes."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="property-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="propertyExtension" upperBound="-2"
-        eType="#//PropertyExtensionType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="      Extension element for property.&#xD;&#xA;                May contain implementation     specific content. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="property-extension"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="propertyName" upperBound="-2"
-        eType="#//PropertyNameType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;property-name&quot; element represents the JavaBeans property name&#xA;    under which the corresponding value may be stored."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="property-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="propertyResolver" upperBound="-2"
-        eType="#//PropertyResolverType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;property-resolver&quot;&#xD;&#xA;                element contains the fully qualified class name     of&#xD;&#xA;                the concrete PropertyResolver implementation class that&#xD;&#xA;                will be used     during the processing of value&#xD;&#xA;                reference expressions.     It must be of type&#xD;&#xA;                &quot;ClassName&quot;. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="property-resolver"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="redirect" upperBound="-2"
-        eType="#//RedirectType" volatile="true" transient="true" derived="true" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;redirect&quot; element&#xD;&#xA;                indicates that navigation to the specified&#xD;&#xA;                &quot;to-view-id&quot; should be accomplished by&#xD;&#xA;                performing an HTTP redirect     rather than the usual&#xD;&#xA;                ViewHandler mechanisms. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="redirect"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="redirectViewParam" upperBound="-2"
-        eType="#//RedirectViewParamType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="view-param"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="referencedBean" upperBound="-2"
-        eType="#//ReferencedBeanType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;referenced-bean&quot;&#xD;&#xA;                element represents at design time the promise     that a&#xD;&#xA;                Java object of the specified type will exist at runtime&#xD;&#xA;                in some     scope, under the specified key.  This can be&#xD;&#xA;                used by design time tools     to construct user&#xD;&#xA;                interface dialogs based on the properties of the&#xD;&#xA;                specified class.  The presence or absence of a&#xD;&#xA;                referenced bean     element has no impact on the&#xD;&#xA;                JavaServer Faces runtime environment     inside a web&#xD;&#xA;                application. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="referenced-bean"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="referencedBeanClass" upperBound="-2"
-        eType="#//ReferencedBeanClassType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;referenced-bean-class&quot; element represents the fully qualified class&#xA;    name of the Java class (either abstract or concrete) or Java interface&#xA;    implemented by the corresponding referenced bean.  It must be of type&#xA;    &quot;ClassName&quot;."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="referenced-bean-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="referencedBeanName" upperBound="-2"
-        eType="#//ReferencedBeanNameType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;referenced-bean-name&quot; element represents the attribute name under&#xA;    which the corresponding referenced bean may be assumed to be stored,&#xA;    in one of the scopes defined by the &quot;Scope&quot; type.  It must be of type&#xA;    &quot;Identifier&quot;."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="referenced-bean-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="renderer" upperBound="-2"
-        eType="#//RendererType" volatile="true" transient="true" derived="true" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;renderer&quot; element&#xD;&#xA;                represents a concrete Renderer implementation     class&#xD;&#xA;                that should be registered under the specified type&#xD;&#xA;                identifier,     in the RenderKit associated with the&#xD;&#xA;                parent render-kit element.  Renderer     types must be&#xD;&#xA;                unique within the RenderKit associated with the parent&#xD;&#xA;                &quot;render-kit&quot; element.      Nested&#xD;&#xA;                &quot;attribute&quot; elements identify generic&#xD;&#xA;                component attributes that     are recognized by this&#xD;&#xA;                renderer.  Nested &quot;supported-component-type&quot;&#xD;&#xA;                and     &quot;supported-component-class&quot; elements&#xD;&#xA;                identify supported component classes,     by their type&#xD;&#xA;                identifiers or the implementation class name,&#xD;&#xA;                respectively,     that are supported by this Renderer. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="renderer"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="rendererClass" upperBound="-2"
-        eType="#//RendererClassType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;renderer-class&quot; element represents the fully qualified class name&#xA;    of a concrete Renderer implementation class.  It must be of&#xA;    type &quot;ClassName&quot;."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="renderer-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="rendererExtension" upperBound="-2"
-        eType="#//RendererExtensionType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="      Extension element for renderer.&#xD;&#xA;                May contain implementation     specific content. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="renderer-extension"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="rendererType" upperBound="-2"
-        eType="#//RendererTypeType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;renderer-type&quot; element represents a renderer type identifier for the&#xA;    Renderer represented by the parent &quot;renderer&quot; element."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="renderer-type"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="renderKit" upperBound="-2"
-        eType="#//RenderKitType" volatile="true" transient="true" derived="true" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;render-kit&quot; element&#xD;&#xA;                represents a concrete RenderKit implementation     that&#xD;&#xA;                should be registered under the specified render-kit-id.&#xD;&#xA;                If no     render-kit-id is specified, the identifier of&#xD;&#xA;                the default RenderKit&#xD;&#xA;                (RenderKitFactory.DEFAULT_RENDER_KIT) is assumed. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="render-kit"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="renderKitClass" upperBound="-2"
-        eType="#//RenderKitClassType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;render-kit-class&quot; element represents the fully qualified class name&#xA;    of a concrete RenderKit implementation class.  It must be of&#xA;    type &quot;ClassName&quot;."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="render-kit-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="renderKitFactory" upperBound="-2"
-        eType="#//RenderKitFactoryType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;render-kit-factory&quot;&#xD;&#xA;                element contains the fully qualified class name     of&#xD;&#xA;                the concrete RenderKitFactory implementation class that&#xD;&#xA;                will be called     when&#xD;&#xA;                FactoryFinder.getFactory(RENDER_KIT_FACTORY) is called.&#xD;&#xA;                It must be      of type &quot;ClassName&quot;. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="render-kit-factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="renderKitId" upperBound="-2"
-        eType="#//RenderKitIdType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;render-kit-id&quot; element represents an identifier for the&#xA;    RenderKit represented by the parent &quot;render-kit&quot; element."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="render-kit-id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="resourceHandler" upperBound="-2"
-        eType="#//ResourceHandlerType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="resource-handler"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="smallIcon" upperBound="-2"
-        eType="#//SmallIconType" volatile="true" transient="true" derived="true" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;small-icon&quot; element contains the resource path to a small (16x16)&#xA;    icon image.  The image may be in either GIF or JPG format."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="small-icon"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="sourceClass" upperBound="-2"
-        eType="#//SourceClassType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="source-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="stateManager" upperBound="-2"
-        eType="#//StateManagerType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="      The &quot;state-manager&quot;&#xD;&#xA;                element contains the fully qualified class name     of&#xD;&#xA;                the concrete StateManager implementation class that will&#xD;&#xA;                be called     during the Restore View and Render&#xD;&#xA;                Response phases of the request     processing lifecycle.&#xD;&#xA;                The faces implementation must provide a     default&#xD;&#xA;                implementation of this class "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="state-manager"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="suggestedValue" upperBound="-2"
-        eType="#//SuggestedValueType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;suggested-value&quot; contains the value for the property or&#xA;    attribute in which this element resides.  This value is advisory&#xA;    only and is intended for tools to use when populating pallettes."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="suggested-value"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="supportedLocale" upperBound="-2"
-        eType="#//SupportedLocaleType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="      The &quot;supported-locale&quot;&#xD;&#xA;                element allows authors to declare which      locales are&#xD;&#xA;                supported in this application instance.       It must be&#xD;&#xA;                specified as :language:[_:country:[_:variant:]] without&#xD;&#xA;                the colons, for example &quot;ja_JP_SJIS&quot;.  The&#xD;&#xA;                separators between the      segments may be&#xD;&#xA;                '-' or '_'. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="supported-locale"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="systemEventClass" upperBound="-2"
-        eType="#//SystemEventClassType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="system-event-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="systemEventListener" upperBound="-2"
-        eType="#//SystemEventListenerType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="system-event-listener"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="systemEventListenerClass"
-        upperBound="-2" eType="#//SystemEventListenerClassType" volatile="true" transient="true"
-        derived="true" containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="system-event-listener-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="tagHandlerDelegateFactory"
-        upperBound="-2" eType="#//TagHandlerDelegateFactoryType" volatile="true" transient="true"
-        derived="true" containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="tag-handler-delegate-factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="toViewId" upperBound="-2"
-        eType="#//ToViewIdType" volatile="true" transient="true" derived="true" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;to-view&quot; element contains the view identifier of the next view&#xA;    that should be displayed if this navigation rule is matched.  It&#xA;    must be of type &quot;ViewId&quot;."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="to-view-id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="validator" upperBound="-2"
-        eType="#//ValidatorType" volatile="true" transient="true" derived="true" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;validator&quot; element&#xD;&#xA;                represents a concrete Validator implementation     class&#xD;&#xA;                that should be registered under the specified validator&#xD;&#xA;                identifier.     Validator identifiers must be unique&#xD;&#xA;                within the entire web application.      Nested&#xD;&#xA;                &quot;attribute&quot; elements identify generic&#xD;&#xA;                attributes that may be     configured on the&#xD;&#xA;                corresponding UIComponent in order to affect the&#xD;&#xA;                operation of the Validator.  Nested &quot;property&quot;&#xD;&#xA;                elements identify JavaBeans     properties of the&#xD;&#xA;                Validator implementation class that may be configured&#xD;&#xA;                to affect the operation of the Validator. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="validator"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="validatorClass" upperBound="-2"
-        eType="#//ValidatorClassType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;validator-class&quot; element represents the fully qualified class name&#xA;    of a concrete Validator implementation class.  It must be of&#xA;    type &quot;ClassName&quot;."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="validator-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="validatorId" upperBound="-2"
-        eType="#//ValidatorIdType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;validator-id&quot; element represents the identifier under which the&#xA;    corresponding Validator class should be registered."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="validator-id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="value" upperBound="-2"
-        eType="#//ValueType" volatile="true" transient="true" derived="true" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;value&quot; element is the&#xD;&#xA;                String representation of a literal     value to which a&#xD;&#xA;                scalar managed property will be set, or a value&#xD;&#xA;                reference expression (&quot;#{...}&quot;) that will be&#xD;&#xA;                used to calculate the     required value.  It will be&#xD;&#xA;                converted as specified for the actual     property type. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="value"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="valueClass" upperBound="-2"
-        eType="#//ValueClassType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="    The &quot;value-class&quot; element defines the Java type to which each&#xA;    &quot;value&quot; element's value will be converted to, prior to adding it to&#xA;    the &quot;list-entries&quot; list for a managed property that is a&#xA;    java.util.List, or a &quot;map-entries&quot; map for a managed property that&#xA;    is a java.util.Map.  It must be of type &quot;ClassName&quot;.  If omitted,&#xA;    &quot;java.lang.String&quot; is assumed."/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="value-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="variableResolver" upperBound="-2"
-        eType="#//VariableResolverType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="     The &quot;variable-resolver&quot;&#xD;&#xA;                element contains the fully qualified class name     of&#xD;&#xA;                the concrete VariableResolver implementation class that&#xD;&#xA;                will be used     during the processing of value&#xD;&#xA;                reference expressions.     It must be of type&#xD;&#xA;                &quot;ClassName&quot;. "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="variable-resolver"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="viewDeclarationLanguageFactory"
-        upperBound="-2" eType="#//ViewDeclarationLanguageFactoryType" volatile="true"
-        transient="true" derived="true" containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="view-declaration-language-factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="viewHandler" upperBound="-2"
-        eType="#//ViewHandlerType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value="      The &quot;view-handler&quot;&#xD;&#xA;                element contains the fully qualified class name     of&#xD;&#xA;                the concrete ViewHandler implementation class that will&#xD;&#xA;                be called     during the Restore View and Render&#xD;&#xA;                Response phases of the request     processing lifecycle.&#xD;&#xA;                The faces implementation must provide a     default&#xD;&#xA;                implementation of this class "/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="view-handler"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="visitContextFactory" upperBound="-2"
-        eType="#//VisitContextFactoryType" volatile="true" transient="true" derived="true"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
-        <details key="documentation" value=""/>
-      </eAnnotations>
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="visit-context-factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="DynamicAttribute">
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="name" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="DynamicElement">
-    <eStructuralFeatures xsi:type="ecore:EReference" name="childNodes" upperBound="-1"
-        eType="#//DynamicElement" containment="true"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="name" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="attributes" upperBound="-1"
-        eType="#//DynamicAttribute"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ELResolverType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="el-resolver_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ExceptionHandlerFactoryType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="exception-handler-factory_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ExtensionType" abstract="true">
-    <eStructuralFeatures xsi:type="ecore:EReference" name="childNodes" upperBound="-1"
-        eType="#//DynamicElement"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ExternalContextFactoryType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="external-context-factory_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="FacesConfigType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="faces-config_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="application" upperBound="-1"
-        eType="#//ApplicationType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="application"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="ordering" upperBound="-1"
-        eType="#//OrderingType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="ordering"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="absoluteOrdering" eType="#//AbsoluteOrderingType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="absolute-ordering"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="factory" upperBound="-1"
-        eType="#//FactoryType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="component" upperBound="-1"
-        eType="#//ComponentType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="component"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="converter" upperBound="-1"
-        eType="#//ConverterType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="converter"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="managedBean" upperBound="-1"
-        eType="#//ManagedBeanType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="managed-bean"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="name" eType="#//NameType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="navigationRule" upperBound="-1"
-        eType="#//NavigationRuleType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="navigation-rule"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="referencedBean" upperBound="-1"
-        eType="#//ReferencedBeanType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="referenced-bean"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="renderKit" upperBound="-1"
-        eType="#//RenderKitType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="render-kit"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="lifecycle" upperBound="-1"
-        eType="#//LifecycleType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="lifecycle"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="validator" upperBound="-1"
-        eType="#//ValidatorType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="validator"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="behavior" upperBound="-1"
-        eType="#//BehaviorType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="behavior"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="facesConfigExtension" upperBound="-1"
-        eType="#//FacesConfigExtensionType">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="faces-config-extension"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="xmlns" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String"
-        defaultValueLiteral="http://java.sun.com/JSF/Configuration" unsettable="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="xmlns"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="metadataComplete" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//Boolean">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="metadata-complete"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="FacesConfigExtensionType" eSuperTypes="#//ExtensionType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="faces-config-extension_._type"/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="FacesContextFactoryType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="faces-context-factory_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="FacetExtensionType" eSuperTypes="#//ExtensionType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="facet-extension_._type"/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="FacetNameType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="facet-name_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="FacetType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="facet_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="description" upperBound="-1"
-        eType="#//DescriptionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="description"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="displayName" upperBound="-1"
-        eType="#//DisplayNameType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="display-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="icon" upperBound="-1" eType="#//IconType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="icon"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="facetName" lowerBound="1"
-        eType="#//FacetNameType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="facet-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="facetExtension" upperBound="-1"
-        eType="#//FacetExtensionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="facet-extension"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="FactoryType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="factory_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="applicationFactory" upperBound="-1"
-        eType="#//ApplicationFactoryType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="application-factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="exceptionHandlerFactory"
-        upperBound="-1" eType="#//ExceptionHandlerFactoryType" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="exception-handler-factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="externalContextFactory"
-        upperBound="-1" eType="#//ExternalContextFactoryType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="external-context-factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="facesContextFactory" upperBound="-1"
-        eType="#//FacesContextFactoryType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="faces-context-factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="partialViewContextFactory"
-        upperBound="-1" eType="#//PartialViewContextFactoryType" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="partial-view-context-factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="lifecycleFactory" upperBound="-1"
-        eType="#//LifecycleFactoryType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="lifecycle-factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="viewDeclarationLanguageFactory"
-        upperBound="-1" eType="#//ViewDeclarationLanguageFactoryType" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="view-declaration-language-factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="tagHandlerDelegateFactory"
-        upperBound="-1" eType="#//TagHandlerDelegateFactoryType" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="tag-handler-delegate-factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="renderKitFactory" upperBound="-1"
-        eType="#//RenderKitFactoryType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="render-kit-factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="visitContextFactory" upperBound="-1"
-        eType="#//VisitContextFactoryType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="visit-context-factory"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="factoryExtension" upperBound="-1"
-        eType="#//FactoryExtensionType">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="factory-type"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="FactoryExtensionType" eSuperTypes="#//ExtensionType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="factory-extension_._type"/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="FromActionType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="from-action_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="FromOutcomeType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="from-outcome_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="FromViewIdType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="from-view-id_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="IconType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="icon_._type"/>
-      <details key="kind" value="empty"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="smallIcon" eType="#//SmallIconType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="small-icon"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="largeIcon" eType="#//LargeIconType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="large-icon"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="lang" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//Language">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="lang"/>
-        <details key="namespace" value="http://www.w3.org/XML/1998/namespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="IfType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="if_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="KeyClassType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="key-class_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="KeyType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="key_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="LargeIconType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="large-icon_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="LifecycleFactoryType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="lifecycle-factory_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="LifecycleType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="lifecycle_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="phaseListener" upperBound="-1"
-        eType="#//PhaseListenerType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="phase-listener"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="lifecycleExtension" upperBound="-1"
-        eType="#//LifecycleExtensionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="lifecycle-extension"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="LifecycleExtensionType" eSuperTypes="#//ExtensionType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="lifecycle-extension_._type"/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ListEntriesType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="list-entries_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="valueClass" eType="#//ValueClassType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="value-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="nullValue" upperBound="-1"
-        eType="#//NullValueType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="null-value"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="value" upperBound="-1"
-        eType="#//ValueType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="value"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="LocaleConfigType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="locale-config_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="defaultLocale" eType="#//DefaultLocaleType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="default-locale"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="supportedLocale" upperBound="-1"
-        eType="#//SupportedLocaleType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="supported-locale"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ManagedBeanClassType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="managed-bean-class_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ManagedBeanNameType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="managed-bean-name_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ManagedBeanScopeType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="managed-bean-scope_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ManagedBeanType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="managed-bean_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="description" upperBound="-1"
-        eType="#//DescriptionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="description"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="displayName" upperBound="-1"
-        eType="#//DisplayNameType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="display-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="icon" upperBound="-1" eType="#//IconType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="icon"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="managedBeanName" lowerBound="1"
-        eType="#//ManagedBeanNameType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="managed-bean-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="managedBeanClass" lowerBound="1"
-        eType="#//ManagedBeanClassType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="managed-bean-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="managedBeanScope" lowerBound="1"
-        eType="#//ManagedBeanScopeType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="managed-bean-scope"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="managedProperty" upperBound="-1"
-        eType="#//ManagedPropertyType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="managed-property"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="mapEntries" eType="#//MapEntriesType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="map-entries"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="listEntries" eType="#//ListEntriesType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="list-entries"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="managedBeanExtension" upperBound="-1"
-        eType="#//ManagedBeanExtensionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="managed-bean-extension"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="eager" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//Boolean">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="eager"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ManagedBeanExtensionType" eSuperTypes="#//ExtensionType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="managed-bean-extension_._type"/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ManagedPropertyType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="managed-property_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="description" upperBound="-1"
-        eType="#//DescriptionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="description"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="displayName" upperBound="-1"
-        eType="#//DisplayNameType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="display-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="icon" upperBound="-1" eType="#//IconType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="icon"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="propertyName" lowerBound="1"
-        eType="#//PropertyNameType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="property-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="propertyClass" eType="#//PropertyClassType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="property-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="mapEntries" eType="#//MapEntriesType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="map-entries"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="nullValue" eType="#//NullValueType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="null-value"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="value" eType="#//ValueType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="value"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="listEntries" eType="#//ListEntriesType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="list-entries"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="MapEntriesType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="map-entries_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="keyClass" eType="#//KeyClassType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="key-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="valueClass" eType="#//ValueClassType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="value-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="mapEntry" upperBound="-1"
-        eType="#//MapEntryType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="map-entry"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="MapEntryType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="map-entry_._type"/>
-      <details key="kind" value="empty"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="key" lowerBound="1" eType="#//KeyType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="key"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="nullValue" eType="#//NullValueType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="null-value"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="value" eType="#//ValueType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="value"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="MessageBundleType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="message-bundle_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="NameType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="name_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="NavigationCaseType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="navigation-case_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="description" upperBound="-1"
-        eType="#//DescriptionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="description"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="displayName" upperBound="-1"
-        eType="#//DisplayNameType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="display-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="icon" upperBound="-1" eType="#//IconType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="icon"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="fromAction" eType="#//FromActionType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="from-action"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="fromOutcome" eType="#//FromOutcomeType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="from-outcome"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="if" eType="#//IfType" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="if"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="toViewId" lowerBound="1"
-        eType="#//ToViewIdType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="to-view-id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="redirect" eType="#//RedirectType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="redirect"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="NavigationHandlerType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="navigation-handler_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="NavigationRuleType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="navigation-rule_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="description" upperBound="-1"
-        eType="#//DescriptionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="description"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="displayName" upperBound="-1"
-        eType="#//DisplayNameType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="display-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="icon" upperBound="-1" eType="#//IconType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="icon"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="fromViewId" eType="#//FromViewIdType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="from-view-id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="navigationCase" upperBound="-1"
-        eType="#//NavigationCaseType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="navigation-case"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="navigationRuleExtension"
-        upperBound="-1" eType="#//NavigationRuleExtensionType" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="navigation-rule-extension"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="NavigationRuleExtensionType" eSuperTypes="#//ExtensionType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="navigation-rule-extension_._type"/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="NullValueType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="null-value_._type"/>
-      <details key="kind" value="empty"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="OrderingType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="ordering_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="before" eType="#//OrderingOrderingType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="before"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="after" eType="#//OrderingOrderingType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="after"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="OrderingOrderingType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="ordering-ordering_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="name" upperBound="-1" eType="#//NameType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="others" eType="#//OrderingOthersType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="others"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="OrderingOthersType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="others_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PartialViewContextFactoryType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="partial-view-context-factory_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PhaseListenerType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="phase-listener_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PropertyClassType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="property-class_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PropertyExtensionType" eSuperTypes="#//ExtensionType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="property-extension_._type"/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PropertyNameType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="property-name_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PropertyResolverType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="property-resolver_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PropertyType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="property_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="description" upperBound="-1"
-        eType="#//DescriptionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="description"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="displayName" upperBound="-1"
-        eType="#//DisplayNameType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="display-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="icon" upperBound="-1" eType="#//IconType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="icon"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="propertyName" lowerBound="1"
-        eType="#//PropertyNameType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="property-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="propertyClass" lowerBound="1"
-        eType="#//PropertyClassType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="property-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="defaultValue" eType="#//DefaultValueType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="default-value"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="suggestedValue" eType="#//SuggestedValueType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="suggested-value"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="propertyExtension" upperBound="-1"
-        eType="#//PropertyExtensionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="property-extension"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="RedirectType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="redirect_._type"/>
-      <details key="kind" value="empty"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="viewParam" upperBound="-1"
-        eType="#//RedirectViewParamType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="view-param"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="includeViewParams" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//Boolean">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="include-view-params"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="RedirectViewParamType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="redirect-viewParam_._type"/>
-      <details key="kind" value="empty"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="name" lowerBound="1" eType="#//NameType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="value" lowerBound="1" eType="#//ValueType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="value"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ReferencedBeanClassType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="referenced-bean-class_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ReferencedBeanNameType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="referenced-bean-name_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ReferencedBeanType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="referenced-bean_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="description" upperBound="-1"
-        eType="#//DescriptionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="description"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="displayName" upperBound="-1"
-        eType="#//DisplayNameType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="display-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="icon" upperBound="-1" eType="#//IconType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="icon"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="referencedBeanName" lowerBound="1"
-        eType="#//ReferencedBeanNameType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="referenced-bean-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="referencedBeanClass" lowerBound="1"
-        eType="#//ReferencedBeanClassType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="referenced-bean-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="RendererClassType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="renderer-class_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="RendererExtensionType" eSuperTypes="#//ExtensionType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="renderer-extension_._type"/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="RendererType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="renderer_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="description" upperBound="-1"
-        eType="#//DescriptionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="description"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="displayName" upperBound="-1"
-        eType="#//DisplayNameType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="display-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="icon" upperBound="-1" eType="#//IconType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="icon"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="componentFamily" lowerBound="1"
-        eType="#//ComponentFamilyType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="component-family"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="rendererType" lowerBound="1"
-        eType="#//RendererTypeType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="renderer-type"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="rendererClass" lowerBound="1"
-        eType="#//RendererClassType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="renderer-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="facet" upperBound="-1"
-        eType="#//FacetType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="facet"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="attribute" upperBound="-1"
-        eType="#//AttributeType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="attribute"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="rendererExtension" upperBound="-1"
-        eType="#//RendererExtensionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="renderer-extension"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="RendererTypeType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="renderer-type_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="RenderKitClassType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="render-kit-class_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="RenderKitFactoryType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="render-kit-factory_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="RenderKitIdType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="render-kit-id_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="RenderKitType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="render-kit_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="description" upperBound="-1"
-        eType="#//DescriptionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="description"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="displayName" upperBound="-1"
-        eType="#//DisplayNameType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="display-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="icon" upperBound="-1" eType="#//IconType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="icon"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="renderKitId" eType="#//RenderKitIdType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="render-kit-id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="renderKitClass" eType="#//RenderKitClassType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="render-kit-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="renderer" upperBound="-1"
-        eType="#//RendererType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="renderer"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="clientBehaviorRenderer"
-        upperBound="-1" eType="#//ClientBehaviorRendererType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="client-behavior-renderer"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="renderKitExtension" upperBound="-1"
-        eType="#//RenderKitExtensionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="render-kit-extension"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="RenderKitExtensionType" eSuperTypes="#//ExtensionType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="render-kit-extension_._type"/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ResourceHandlerType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="resource-handler_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="SmallIconType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="small-icon_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="SourceClassType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="source-class_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="StateManagerType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="state-manager_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="SuggestedValueType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="suggested-value_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="SupportedLocaleType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="supported-locale_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="SystemEventClassType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="system-event-class_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="SystemEventListenerClassType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="system-event-listener-class_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="SystemEventListenerType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="system-event-listener_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="systemEventListenerClass"
-        lowerBound="1" eType="#//SystemEventListenerClassType" containment="true"
-        resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="system-event-listener-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="systemEventClass" lowerBound="1"
-        eType="#//SystemEventClassType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="system-event-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="sourceClass" eType="#//SourceClassType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="source-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="TagHandlerDelegateFactoryType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="tag-handler-delegate-factory_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ToViewIdType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="to-view-id_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ValidatorClassType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="validator-class_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ValidatorIdType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="validator-id_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ValidatorType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="validator_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="description" upperBound="-1"
-        eType="#//DescriptionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="description"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="displayName" upperBound="-1"
-        eType="#//DisplayNameType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="display-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="icon" upperBound="-1" eType="#//IconType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="icon"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="validatorId" lowerBound="1"
-        eType="#//ValidatorIdType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="validator-id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="validatorClass" lowerBound="1"
-        eType="#//ValidatorClassType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="validator-class"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="attribute" upperBound="-1"
-        eType="#//AttributeType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="attribute"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="property" upperBound="-1"
-        eType="#//PropertyType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="property"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="validatorExtension" upperBound="-1"
-        eType="#//ValidatorExtensionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="validator-extension"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ValidatorExtensionType" eSuperTypes="#//ExtensionType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="validator-extension_._type"/>
-    </eAnnotations>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ValueClassType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="value-class_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ValueType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="value_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="VariableResolverType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="variable-resolver_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ViewHandlerType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="view-handler_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ResourceBundleType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="resourceBundle_._type"/>
-      <details key="kind" value="elementOnly"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="description" upperBound="-1"
-        eType="#//DescriptionType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="description"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="displayName" upperBound="-1"
-        eType="#//DisplayNameType" containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="display-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="icon" upperBound="-1" eType="#//IconType"
-        containment="true" resolveProxies="false">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="icon"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="baseName" eType="#//BaseNameType">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="base-name"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="var" eType="#//VarType">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="element"/>
-        <details key="name" value="var"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="BaseNameType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="base-name_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="VarType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="var_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="ViewDeclarationLanguageFactoryType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="view-declaration-language-factory_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="VisitContextFactoryType">
-    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-      <details key="name" value="visit-context-factory_._type"/>
-      <details key="kind" value="simple"/>
-    </eAnnotations>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="textContent" unique="false"
-        eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//String">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="name" value=":0"/>
-        <details key="kind" value="simple"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="id" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2003/XMLType#//ID"
-        iD="true">
-      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
-        <details key="kind" value="attribute"/>
-        <details key="name" value="id"/>
-        <details key="namespace" value="##targetNamespace"/>
-      </eAnnotations>
-    </eStructuralFeatures>
-  </eClassifiers>
-</ecore:EPackage>
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/model/facesConfig.genmodel b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/model/facesConfig.genmodel
deleted file mode 100644
index 8ed8544..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/model/facesConfig.genmodel
+++ /dev/null
@@ -1,738 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<genmodel:GenModel xmi:version="2.0"
-    xmlns:xmi="http://www.omg.org/XMI" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore"
-    xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" copyrightText="Copyright (c) 2005, 2006 IBM Corporation and others"
-    modelDirectory="/org.eclipse.jst.jsf.facesconfig/facesconfig" editDirectory="/org.eclipse.jst.jsf.facesconfig/facesconfig"
-    editorDirectory="/org.eclipse.jst.jsf.facesconfig.editor/src" modelPluginID="org.eclipse.jst.jsf.facesconfig"
-    templateDirectory="org.eclipse.jst.jsf.facesconfig/model/templates" dynamicTemplates="true"
-    redirection="" modelName="FacesConfig" modelPluginClass="" editPluginClass="org.eclipse.jst.jsf.facesconfig.FacesConfigPlugin"
-    editorPluginClass="org.eclipse.jst.jsf.facesconfig.emf.presentation.FacesConfigEditorPlugin"
-    rootImplementsInterface="" featureMapWrapperInterface="" featureMapWrapperInternalInterface=""
-    featureMapWrapperClass="" testSuiteClass="org.eclipse.jst.jsf.facesconfig.emf.tests.FacesConfigAllTests"
-    booleanFlagsField="">
-  <foreignModel>../../../com.ibm.etools.jsf/facesConfig.xsd</foreignModel>
-  <genPackages prefix="FacesConfig" basePackage="org.eclipse.jst.jsf" disposableProviderFactory="true"
-      interfacePackageSuffix="emf" metaDataPackageSuffix="emf" classPackageSuffix="emf.impl"
-      utilityPackageSuffix="emf.util" providerPackageSuffix="edit.provider" presentationPackageSuffix="emf.presentation"
-      testsPackageSuffix="emf.tests" ecorePackage="FacesConfig.ecore#/">
-    <genClasses ecoreClass="FacesConfig.ecore#//AbsoluteOrderingType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//AbsoluteOrderingType/id"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//AbsoluteOrderingType/name"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//AbsoluteOrderingType/others"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ActionListenerType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ActionListenerType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ActionListenerType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ApplicationFactoryType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ApplicationFactoryType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ApplicationFactoryType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ApplicationType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ApplicationType/actionListener"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ApplicationType/defaultRenderKitId"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ApplicationType/messageBundle"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ApplicationType/navigationHandler"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ApplicationType/partialTraversal"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ApplicationType/viewHandler"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ApplicationType/stateManager"/>
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ApplicationType/eLResolver"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ApplicationType/propertyResolver"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ApplicationType/variableResolver"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ApplicationType/resourceHandler"/>
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ApplicationType/systemEventListener"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ApplicationType/localeConfig"/>
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ApplicationType/resourceBundle"/>
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ApplicationType/applicationExtension"/>
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ApplicationType/defaultValidators"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ApplicationType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ApplicationExtensionType"/>
-    <genClasses ecoreClass="FacesConfig.ecore#//AttributeClassType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//AttributeClassType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//AttributeClassType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//AttributeExtensionType"/>
-    <genClasses ecoreClass="FacesConfig.ecore#//AttributeNameType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//AttributeNameType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//AttributeNameType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//AttributeType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//AttributeType/description"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//AttributeType/displayName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//AttributeType/icon"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//AttributeType/attributeName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//AttributeType/attributeClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//AttributeType/defaultValue"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//AttributeType/suggestedValue"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//AttributeType/attributeExtension"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//AttributeType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//BehaviorClassType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//BehaviorClassType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//BehaviorClassType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//BehaviorIdType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//BehaviorIdType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//BehaviorIdType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//BehaviorType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//BehaviorType/description"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//BehaviorType/displayName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//BehaviorType/icon"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//BehaviorType/behaviorId"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//BehaviorType/behaviorClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//BehaviorType/attribute"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//BehaviorType/property"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//BehaviorType/behaviorExtension"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//BehaviorType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//BehaviorExtensionType"/>
-    <genClasses ecoreClass="FacesConfig.ecore#//ClientBehaviorRendererClassType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ClientBehaviorRendererClassType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ClientBehaviorRendererClassType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ClientBehaviorRendererType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ClientBehaviorRendererType/clientBehaviorRendererType"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ClientBehaviorRendererType/clientBehaviorRendererClass"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ClientBehaviorRendererType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ClientBehaviorRendererTypeType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ClientBehaviorRendererTypeType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ClientBehaviorRendererTypeType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ComponentClassType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ComponentClassType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ComponentClassType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ComponentExtensionType"/>
-    <genClasses ecoreClass="FacesConfig.ecore#//ComponentFamilyType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ComponentFamilyType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ComponentFamilyType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ComponentType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ComponentType/description"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ComponentType/displayName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ComponentType/icon"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ComponentType/componentType"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ComponentType/componentClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ComponentType/facet"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ComponentType/attribute"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ComponentType/property"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ComponentType/componentExtension"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ComponentType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ComponentTypeType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ComponentTypeType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ComponentTypeType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ConverterClassType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ConverterClassType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ConverterClassType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ConverterForClassType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ConverterForClassType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ConverterForClassType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ConverterIdType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ConverterIdType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ConverterIdType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ConverterType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ConverterType/description"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ConverterType/displayName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ConverterType/icon"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ConverterType/converterId"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ConverterType/converterForClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ConverterType/converterClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ConverterType/attribute"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ConverterType/property"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ConverterType/converterExtension"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ConverterType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ConverterExtensionType"/>
-    <genClasses ecoreClass="FacesConfig.ecore#//DefaultLocaleType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//DefaultLocaleType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//DefaultLocaleType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//DefaultRenderKitIdType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//DefaultRenderKitIdType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//DefaultRenderKitIdType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//DefaultValidatorsType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DefaultValidatorsType/validatorId"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//DefaultValidatorsType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//DefaultValueType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//DefaultValueType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//DefaultValueType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//DescriptionType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//DescriptionType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//DescriptionType/lang"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//DescriptionType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//DisplayNameType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//DisplayNameType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//DisplayNameType/lang"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//DisplayNameType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//DocumentRoot">
-      <genFeatures property="None" notify="false" createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//DocumentRoot/mixed"/>
-      <genFeatures property="None" notify="false" createChild="false" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/xMLNSPrefixMap"/>
-      <genFeatures property="None" notify="false" createChild="false" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/xSISchemaLocation"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/absoluteOrdering"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/actionListener"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/application"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/applicationFactory"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/attribute"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/attributeClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/attributeExtension"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/attributeName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/behavior"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/behaviorClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/behaviorId"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/behaviorExtension"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/component"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/componentClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/componentExtension"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/componentFamily"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/componentType"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/converter"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/converterClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/converterForClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/converterId"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/defaultLocale"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/defaultRenderKitId"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/defaultValidators"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/defaultValue"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/description"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/displayName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/exceptionHandlerFactory"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/externalContextFactory"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/facesConfig"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/facesContextFactory"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/facet"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/facetExtension"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/facetName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/factory"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/fromAction"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/fromOutcome"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/fromViewId"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/icon"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/if"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/key"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/keyClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/largeIcon"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/lifecycle"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/lifecycleFactory"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/listEntries"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/localeConfig"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/managedBean"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/managedBeanClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/managedBeanName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/managedBeanScope"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/managedProperty"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/mapEntries"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/mapEntry"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/messageBundle"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/name"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/navigationCase"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/navigationHandler"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/navigationRule"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/nullValue"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/ordering"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/orderingOrdering"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/others"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/partialTraversal"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/partialViewContextFactory"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/phaseListener"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/property"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/propertyClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/propertyExtension"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/propertyName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/propertyResolver"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/redirect"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/redirectViewParam"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/referencedBean"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/referencedBeanClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/referencedBeanName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/renderer"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/rendererClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/rendererExtension"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/rendererType"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/renderKit"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/renderKitClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/renderKitFactory"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/renderKitId"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/resourceHandler"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/smallIcon"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/sourceClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/stateManager"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/suggestedValue"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/supportedLocale"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/systemEventClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/systemEventListener"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/systemEventListenerClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/tagHandlerDelegateFactory"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/toViewId"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/validator"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/validatorClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/validatorId"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/value"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/valueClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/variableResolver"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/viewDeclarationLanguageFactory"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/viewHandler"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DocumentRoot/visitContextFactory"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//DynamicAttribute">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//DynamicAttribute/name"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//DynamicAttribute/value"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//DynamicElement">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DynamicElement/childNodes"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//DynamicElement/name"/>
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//DynamicElement/attributes"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//DynamicElement/textContent"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ELResolverType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ELResolverType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ELResolverType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ExceptionHandlerFactoryType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ExceptionHandlerFactoryType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ExceptionHandlerFactoryType/id"/>
-    </genClasses>
-    <genClasses image="false" ecoreClass="FacesConfig.ecore#//ExtensionType">
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ExtensionType/childNodes"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ExtensionType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ExtensionType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ExternalContextFactoryType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ExternalContextFactoryType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ExternalContextFactoryType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//FacesConfigType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FacesConfigType/application"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FacesConfigType/ordering"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FacesConfigType/absoluteOrdering"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FacesConfigType/factory"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FacesConfigType/component"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FacesConfigType/converter"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FacesConfigType/managedBean"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FacesConfigType/name"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FacesConfigType/navigationRule"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FacesConfigType/referencedBean"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FacesConfigType/renderKit"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FacesConfigType/lifecycle"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FacesConfigType/validator"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FacesConfigType/behavior"/>
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FacesConfigType/facesConfigExtension"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//FacesConfigType/xmlns"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//FacesConfigType/id"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//FacesConfigType/metadataComplete"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//FacesConfigExtensionType"/>
-    <genClasses ecoreClass="FacesConfig.ecore#//FacesContextFactoryType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//FacesContextFactoryType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//FacesContextFactoryType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//FacetExtensionType"/>
-    <genClasses ecoreClass="FacesConfig.ecore#//FacetNameType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//FacetNameType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//FacetNameType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//FacetType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FacetType/description"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FacetType/displayName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FacetType/icon"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FacetType/facetName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FacetType/facetExtension"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//FacetType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//FactoryType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FactoryType/applicationFactory"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FactoryType/exceptionHandlerFactory"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FactoryType/externalContextFactory"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FactoryType/facesContextFactory"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FactoryType/partialViewContextFactory"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FactoryType/lifecycleFactory"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FactoryType/viewDeclarationLanguageFactory"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FactoryType/tagHandlerDelegateFactory"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FactoryType/renderKitFactory"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FactoryType/visitContextFactory"/>
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//FactoryType/factoryExtension"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//FactoryType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//FactoryExtensionType"/>
-    <genClasses ecoreClass="FacesConfig.ecore#//FromActionType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//FromActionType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//FromActionType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//FromOutcomeType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//FromOutcomeType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//FromOutcomeType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//FromViewIdType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//FromViewIdType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//FromViewIdType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//IconType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//IconType/smallIcon"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//IconType/largeIcon"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//IconType/lang"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//IconType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//IfType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//IfType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//IfType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//KeyClassType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//KeyClassType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//KeyClassType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//KeyType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//KeyType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//KeyType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//LargeIconType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//LargeIconType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//LargeIconType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//LifecycleFactoryType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//LifecycleFactoryType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//LifecycleFactoryType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//LifecycleType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//LifecycleType/phaseListener"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//LifecycleType/lifecycleExtension"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//LifecycleType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//LifecycleExtensionType"/>
-    <genClasses ecoreClass="FacesConfig.ecore#//ListEntriesType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ListEntriesType/valueClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ListEntriesType/nullValue"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ListEntriesType/value"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ListEntriesType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//LocaleConfigType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//LocaleConfigType/defaultLocale"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//LocaleConfigType/supportedLocale"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//LocaleConfigType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ManagedBeanClassType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ManagedBeanClassType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ManagedBeanClassType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ManagedBeanNameType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ManagedBeanNameType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ManagedBeanNameType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ManagedBeanScopeType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ManagedBeanScopeType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ManagedBeanScopeType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ManagedBeanType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ManagedBeanType/description"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ManagedBeanType/displayName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ManagedBeanType/icon"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ManagedBeanType/managedBeanName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ManagedBeanType/managedBeanClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ManagedBeanType/managedBeanScope"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ManagedBeanType/managedProperty"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ManagedBeanType/mapEntries"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ManagedBeanType/listEntries"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ManagedBeanType/managedBeanExtension"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ManagedBeanType/id"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ManagedBeanType/eager"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ManagedBeanExtensionType"/>
-    <genClasses ecoreClass="FacesConfig.ecore#//ManagedPropertyType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ManagedPropertyType/description"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ManagedPropertyType/displayName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ManagedPropertyType/icon"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ManagedPropertyType/propertyName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ManagedPropertyType/propertyClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ManagedPropertyType/mapEntries"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ManagedPropertyType/nullValue"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ManagedPropertyType/value"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ManagedPropertyType/listEntries"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ManagedPropertyType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//MapEntriesType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//MapEntriesType/keyClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//MapEntriesType/valueClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//MapEntriesType/mapEntry"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//MapEntriesType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//MapEntryType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//MapEntryType/key"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//MapEntryType/nullValue"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//MapEntryType/value"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//MapEntryType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//MessageBundleType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//MessageBundleType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//MessageBundleType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//NameType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//NameType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//NameType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//NavigationCaseType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//NavigationCaseType/description"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//NavigationCaseType/displayName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//NavigationCaseType/icon"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//NavigationCaseType/fromAction"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//NavigationCaseType/fromOutcome"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//NavigationCaseType/if"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//NavigationCaseType/toViewId"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//NavigationCaseType/redirect"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//NavigationCaseType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//NavigationHandlerType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//NavigationHandlerType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//NavigationHandlerType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//NavigationRuleType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//NavigationRuleType/description"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//NavigationRuleType/displayName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//NavigationRuleType/icon"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//NavigationRuleType/fromViewId"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//NavigationRuleType/navigationCase"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//NavigationRuleType/navigationRuleExtension"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//NavigationRuleType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//NavigationRuleExtensionType"/>
-    <genClasses ecoreClass="FacesConfig.ecore#//NullValueType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//NullValueType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//OrderingType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//OrderingType/id"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//OrderingType/before"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//OrderingType/after"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//OrderingOrderingType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//OrderingOrderingType/id"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//OrderingOrderingType/name"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//OrderingOrderingType/others"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//OrderingOthersType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//OrderingOthersType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//PartialTraversalType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//PartialTraversalType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//PartialTraversalType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//PartialViewContextFactoryType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//PartialViewContextFactoryType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//PartialViewContextFactoryType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//PhaseListenerType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//PhaseListenerType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//PhaseListenerType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//PropertyClassType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//PropertyClassType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//PropertyClassType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//PropertyExtensionType"/>
-    <genClasses ecoreClass="FacesConfig.ecore#//PropertyNameType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//PropertyNameType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//PropertyNameType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//PropertyResolverType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//PropertyResolverType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//PropertyResolverType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//PropertyType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//PropertyType/description"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//PropertyType/displayName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//PropertyType/icon"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//PropertyType/propertyName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//PropertyType/propertyClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//PropertyType/defaultValue"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//PropertyType/suggestedValue"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//PropertyType/propertyExtension"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//PropertyType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//RedirectType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//RedirectType/viewParam"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//RedirectType/id"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//RedirectType/includeViewParams"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//RedirectViewParamType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//RedirectViewParamType/name"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//RedirectViewParamType/value"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//RedirectViewParamType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ReferencedBeanClassType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ReferencedBeanClassType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ReferencedBeanClassType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ReferencedBeanNameType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ReferencedBeanNameType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ReferencedBeanNameType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ReferencedBeanType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ReferencedBeanType/description"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ReferencedBeanType/displayName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ReferencedBeanType/icon"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ReferencedBeanType/referencedBeanName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ReferencedBeanType/referencedBeanClass"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ReferencedBeanType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//RendererClassType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//RendererClassType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//RendererClassType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//RendererExtensionType"/>
-    <genClasses ecoreClass="FacesConfig.ecore#//RendererType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//RendererType/description"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//RendererType/displayName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//RendererType/icon"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//RendererType/componentFamily"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//RendererType/rendererType"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//RendererType/rendererClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//RendererType/facet"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//RendererType/attribute"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//RendererType/rendererExtension"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//RendererType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//RendererTypeType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//RendererTypeType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//RendererTypeType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//RenderKitClassType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//RenderKitClassType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//RenderKitClassType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//RenderKitFactoryType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//RenderKitFactoryType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//RenderKitFactoryType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//RenderKitIdType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//RenderKitIdType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//RenderKitIdType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//RenderKitType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//RenderKitType/description"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//RenderKitType/displayName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//RenderKitType/icon"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//RenderKitType/renderKitId"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//RenderKitType/renderKitClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//RenderKitType/renderer"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//RenderKitType/clientBehaviorRenderer"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//RenderKitType/renderKitExtension"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//RenderKitType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//RenderKitExtensionType"/>
-    <genClasses ecoreClass="FacesConfig.ecore#//ResourceHandlerType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ResourceHandlerType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ResourceHandlerType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//SmallIconType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//SmallIconType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//SmallIconType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//SourceClassType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//SourceClassType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//SourceClassType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//StateManagerType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//StateManagerType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//StateManagerType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//SuggestedValueType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//SuggestedValueType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//SuggestedValueType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//SupportedLocaleType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//SupportedLocaleType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//SupportedLocaleType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//SystemEventClassType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//SystemEventClassType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//SystemEventClassType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//SystemEventListenerClassType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//SystemEventListenerClassType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//SystemEventListenerClassType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//SystemEventListenerType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//SystemEventListenerType/systemEventListenerClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//SystemEventListenerType/systemEventClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//SystemEventListenerType/sourceClass"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//SystemEventListenerType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//TagHandlerDelegateFactoryType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//TagHandlerDelegateFactoryType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//TagHandlerDelegateFactoryType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ToViewIdType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ToViewIdType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ToViewIdType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ValidatorClassType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ValidatorClassType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ValidatorClassType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ValidatorIdType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ValidatorIdType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ValidatorIdType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ValidatorType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ValidatorType/description"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ValidatorType/displayName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ValidatorType/icon"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ValidatorType/validatorId"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ValidatorType/validatorClass"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ValidatorType/attribute"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ValidatorType/property"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ValidatorType/validatorExtension"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ValidatorType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ValidatorExtensionType"/>
-    <genClasses ecoreClass="FacesConfig.ecore#//ValueClassType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ValueClassType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ValueClassType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ValueType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ValueType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ValueType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//VariableResolverType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//VariableResolverType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//VariableResolverType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ViewHandlerType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ViewHandlerType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ViewHandlerType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ResourceBundleType">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ResourceBundleType/description"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ResourceBundleType/displayName"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ResourceBundleType/icon"/>
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ResourceBundleType/baseName"/>
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference FacesConfig.ecore#//ResourceBundleType/var"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ResourceBundleType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//BaseNameType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//BaseNameType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//BaseNameType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//VarType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//VarType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//VarType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//ViewDeclarationLanguageFactoryType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ViewDeclarationLanguageFactoryType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//ViewDeclarationLanguageFactoryType/id"/>
-    </genClasses>
-    <genClasses ecoreClass="FacesConfig.ecore#//VisitContextFactoryType">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//VisitContextFactoryType/textContent"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute FacesConfig.ecore#//VisitContextFactoryType/id"/>
-    </genClasses>
-  </genPackages>
-</genmodel:GenModel>
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/model/templates/Header.javajetinc b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/model/templates/Header.javajetinc
deleted file mode 100644
index 8612b81..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/model/templates/Header.javajetinc
+++ /dev/null
@@ -1,11 +0,0 @@
-/***************************************************************************************************
- * Copyright (c) 2005, 2006 IBM Corporation and others. 
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors: 
- *   IBM Corporation - initial API and implementation
- *   Oracle Corporation - revision
- **************************************************************************************************/
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/plugin.properties b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/plugin.properties
deleted file mode 100644
index 3bf0208..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/plugin.properties
+++ /dev/null
@@ -1,691 +0,0 @@
-###############################################################################
-# Copyright (c) 2005 Oracle Corporation.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-#
-###############################################################################
-plugin.name = JavaServer Faces Tools - FacesConfig Model
-plugin.provider=Eclipse.org
-
-################
-# Content Type #
-################
-
-facesconfig.name = Faces Configuration File
-
-###########
-# Editors #
-###########
-
-facesconfig.editor.name = Faces Configuration File Editor
-OVERVIEW_PAGE_NAME = Overview
-APPLICATION_PAGE_NAME = Application
-FACTORY_PAGE_NAME = Factory
-COMPONENT_PAGE_NAME = Component
-CONVERTER_PAGE_NAME = Converter
-MANAGEDBEAN_PAGE_NAME = Managed Bean
-NAVIGATIONRULE_PAGE_NAME = Navigation Rule
-REFERENCEDBEAN_PAGE_NAME = Referenced Bean
-RENDERKIT_PAGE_NAME = RederKit
-LIFECYCLE_PAGE_NAME = Lifecycle
-VALIDATOR_PAGE_NAME = Validator
-SOURCE_PAGE_NAME = Source
-
-
-facesValidation.name = Faces Configuration File Validator
-# ====================================================================
-
-_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_ActionListenerType_type = Action Listener Type
-_UI_ApplicationFactoryType_type = Application Factory Type
-_UI_ApplicationType_type = Application Type
-_UI_AttributeClassType_type = Attribute Class Type
-_UI_AttributeExtensionType_type = Attribute Extension Type
-_UI_AttributeNameType_type = Attribute Name Type
-_UI_AttributeType_type = Attribute Type
-_UI_ComponentClassType_type = Component Class Type
-_UI_ComponentExtensionType_type = Component Extension Type
-_UI_ComponentFamilyType_type = Component Family Type
-_UI_ComponentType_type = Component
-_UI_ComponentTypeType_type = Component Type Type
-_UI_ConverterClassType_type = Converter Class Type
-_UI_ConverterForClassType_type = Converter For Class Type
-_UI_ConverterIdType_type = Converter Id Type
-_UI_ConverterType_type = Converter
-_UI_DefaultLocaleType_type = Default Locale Type
-_UI_DefaultRenderKitIdType_type = Default Render Kit Id Type
-_UI_DefaultValueType_type = Default Value Type
-_UI_DescriptionType_type = Description Type
-_UI_DisplayNameType_type = Display Name Type
-_UI_DocumentRoot_type = Document Root
-_UI_FacesConfigType_type = Type
-_UI_FacesContextFactoryType_type = Faces Context Factory Type
-_UI_FacetExtensionType_type = Facet Extension Type
-_UI_FacetNameType_type = Facet Name Type
-_UI_FacetType_type = Facet Type
-_UI_FactoryType_type = Factory Type
-_UI_FromActionType_type = From Action Type
-_UI_FromOutcomeType_type = From Outcome Type
-_UI_FromViewIdType_type = From View Id Type
-_UI_IconType_type = Icon Type
-_UI_KeyClassType_type = Key Class Type
-_UI_KeyType_type = Key Type
-_UI_LargeIconType_type = Large Icon Type
-_UI_LifecycleFactoryType_type = Lifecycle Factory Type
-_UI_LifecycleType_type = Lifecycle Type
-_UI_ListEntriesType_type = List Entries Type
-_UI_LocaleConfigType_type = Locale Config Type
-_UI_ManagedBeanClassType_type = Managed Bean Class Type
-_UI_ManagedBeanNameType_type = Managed Bean Name Type
-_UI_ManagedBeanScopeType_type = Managed Bean Scope Type
-_UI_ManagedBeanType_type = Managed Bean Type
-_UI_ManagedPropertyType_type = Managed Property Type
-_UI_MapEntriesType_type = Map Entries Type
-_UI_MapEntryType_type = Map Entry Type
-_UI_MessageBundleType_type = Message Bundle Type
-_UI_NavigationCaseType_type = Navigation Case Type
-_UI_NavigationHandlerType_type = Navigation Handler Type
-_UI_NavigationRuleType_type = Navigation Rule Type
-_UI_NullValueType_type = Null Value Type
-_UI_PhaseListenerType_type = Phase Listener Type
-_UI_PropertyClassType_type = Property Class Type
-_UI_PropertyExtensionType_type = Property Extension Type
-_UI_PropertyNameType_type = Property Name Type
-_UI_PropertyResolverType_type = Property Resolver Type
-_UI_PropertyType_type = Property Type
-_UI_RedirectType_type = Redirect Type
-_UI_ReferencedBeanClassType_type = Referenced Bean Class Type
-_UI_ReferencedBeanNameType_type = Referenced Bean Name Type
-_UI_ReferencedBeanType_type = Referenced Bean Type
-_UI_RendererClassType_type = Renderer Class Type
-_UI_RendererExtensionType_type = Renderer Extension Type
-_UI_RendererType_type = Renderer Type
-_UI_RendererTypeType_type = Renderer Type Type
-_UI_RenderKitClassType_type = Render Kit Class Type
-_UI_RenderKitFactoryType_type = Render Kit Factory Type
-_UI_RenderKitIdType_type = Render Kit Id Type
-_UI_RenderKitType_type = Render Kit
-_UI_SmallIconType_type = Small Icon Type
-_UI_StateManagerType_type = State Manager Type
-_UI_SuggestedValueType_type = Suggested Value Type
-_UI_SupportedLocaleType_type = Supported Locale Type
-_UI_ToViewIdType_type = To View Id Type
-_UI_ValidatorClassType_type = Validator Class Type
-_UI_ValidatorIdType_type = Validator Id Type
-_UI_ValidatorType_type = Validator
-_UI_ValueClassType_type = Value Class Type
-_UI_ValueType_type = Value Type
-_UI_VariableResolverType_type = Variable Resolver Type
-_UI_ViewHandlerType_type = View Handler Type
-_UI_Unknown_type = Object
-
-_UI_Unknown_datatype= Value
-
-_UI_ActionListenerType_textContent_feature = Text Content
-_UI_ActionListenerType_id_feature = Id
-_UI_ApplicationFactoryType_textContent_feature = Text Content
-_UI_ApplicationFactoryType_id_feature = Id
-_UI_ApplicationType_actionListener_feature = Action Listener
-_UI_ApplicationType_defaultRenderKitId_feature = Default Render Kit Id
-_UI_ApplicationType_messageBundle_feature = Message Bundle
-_UI_ApplicationType_navigationHandler_feature = Navigation Handler
-_UI_ApplicationType_viewHandler_feature = View Handler
-_UI_ApplicationType_stateManager_feature = State Manager
-_UI_ApplicationType_propertyResolver_feature = Property Resolver
-_UI_ApplicationType_variableResolver_feature = Variable Resolver
-_UI_ApplicationType_localeConfig_feature = Locale Config
-_UI_ApplicationType_id_feature = Id
-_UI_AttributeClassType_textContent_feature = Text Content
-_UI_AttributeClassType_id_feature = Id
-_UI_AttributeExtensionType_mixed_feature = Mixed
-_UI_AttributeExtensionType_group_feature = Group
-_UI_AttributeExtensionType_any_feature = Any
-_UI_AttributeExtensionType_id_feature = Id
-_UI_AttributeNameType_textContent_feature = Text Content
-_UI_AttributeNameType_id_feature = Id
-_UI_AttributeType_description_feature = Description
-_UI_AttributeType_displayName_feature = Display Name
-_UI_AttributeType_icon_feature = Icon
-_UI_AttributeType_attributeName_feature = Attribute Name
-_UI_AttributeType_attributeClass_feature = Attribute Class
-_UI_AttributeType_defaultValue_feature = Default Value
-_UI_AttributeType_suggestedValue_feature = Suggested Value
-_UI_AttributeType_attributeExtension_feature = Attribute Extension
-_UI_AttributeType_id_feature = Id
-_UI_ComponentClassType_textContent_feature = Text Content
-_UI_ComponentClassType_id_feature = Id
-_UI_ComponentExtensionType_mixed_feature = Mixed
-_UI_ComponentExtensionType_group_feature = Group
-_UI_ComponentExtensionType_any_feature = Any
-_UI_ComponentExtensionType_id_feature = Id
-_UI_ComponentFamilyType_textContent_feature = Text Content
-_UI_ComponentFamilyType_id_feature = Id
-_UI_ComponentType_description_feature = Description
-_UI_ComponentType_displayName_feature = Display Name
-_UI_ComponentType_icon_feature = Icon
-_UI_ComponentType_componentType_feature = Component Type
-_UI_ComponentType_componentClass_feature = Component Class
-_UI_ComponentType_facet_feature = Facet
-_UI_ComponentType_attribute_feature = Attribute
-_UI_ComponentType_property_feature = Property
-_UI_ComponentType_componentExtension_feature = Component Extension
-_UI_ComponentType_id_feature = Id
-_UI_ComponentTypeType_textContent_feature = Text Content
-_UI_ComponentTypeType_id_feature = Id
-_UI_ConverterClassType_textContent_feature = Text Content
-_UI_ConverterClassType_id_feature = Id
-_UI_ConverterForClassType_textContent_feature = Text Content
-_UI_ConverterForClassType_id_feature = Id
-_UI_ConverterIdType_textContent_feature = Text Content
-_UI_ConverterIdType_id_feature = Id
-_UI_ConverterType_description_feature = Description
-_UI_ConverterType_displayName_feature = Display Name
-_UI_ConverterType_icon_feature = Icon
-_UI_ConverterType_converterId_feature = Converter Id
-_UI_ConverterType_converterForClass_feature = Converter For Class
-_UI_ConverterType_converterClass_feature = Converter Class
-_UI_ConverterType_attribute_feature = Attribute
-_UI_ConverterType_property_feature = Property
-_UI_ConverterType_id_feature = Id
-_UI_DefaultLocaleType_textContent_feature = Text Content
-_UI_DefaultLocaleType_id_feature = Id
-_UI_DefaultRenderKitIdType_textContent_feature = Text Content
-_UI_DefaultRenderKitIdType_id_feature = Id
-_UI_DefaultValueType_textContent_feature = Text Content
-_UI_DefaultValueType_id_feature = Id
-_UI_DescriptionType_textContent_feature = Text Content
-_UI_DescriptionType_lang_feature = Lang
-_UI_DescriptionType_id_feature = Id
-_UI_DisplayNameType_textContent_feature = Text Content
-_UI_DisplayNameType_lang_feature = Lang
-_UI_DisplayNameType_id_feature = Id
-_UI_DocumentRoot_mixed_feature = Mixed
-_UI_DocumentRoot_xMLNSPrefixMap_feature = XMLNS Prefix Map
-_UI_DocumentRoot_xSISchemaLocation_feature = XSI Schema Location
-_UI_DocumentRoot_actionListener_feature = Action Listener
-_UI_DocumentRoot_application_feature = Application
-_UI_DocumentRoot_applicationFactory_feature = Application Factory
-_UI_DocumentRoot_attribute_feature = Attribute
-_UI_DocumentRoot_attributeClass_feature = Attribute Class
-_UI_DocumentRoot_attributeExtension_feature = Attribute Extension
-_UI_DocumentRoot_attributeName_feature = Attribute Name
-_UI_DocumentRoot_component_feature = Component
-_UI_DocumentRoot_componentClass_feature = Component Class
-_UI_DocumentRoot_componentExtension_feature = Component Extension
-_UI_DocumentRoot_componentFamily_feature = Component Family
-_UI_DocumentRoot_componentType_feature = Component Type
-_UI_DocumentRoot_converter_feature = Converter
-_UI_DocumentRoot_converterClass_feature = Converter Class
-_UI_DocumentRoot_converterForClass_feature = Converter For Class
-_UI_DocumentRoot_converterId_feature = Converter Id
-_UI_DocumentRoot_defaultLocale_feature = Default Locale
-_UI_DocumentRoot_defaultRenderKitId_feature = Default Render Kit Id
-_UI_DocumentRoot_defaultValue_feature = Default Value
-_UI_DocumentRoot_description_feature = Description
-_UI_DocumentRoot_displayName_feature = Display Name
-_UI_DocumentRoot_facesConfig_feature = Faces Config
-_UI_DocumentRoot_facesContextFactory_feature = Faces Context Factory
-_UI_DocumentRoot_facet_feature = Facet
-_UI_DocumentRoot_facetExtension_feature = Facet Extension
-_UI_DocumentRoot_facetName_feature = Facet Name
-_UI_DocumentRoot_factory_feature = Factory
-_UI_DocumentRoot_fromAction_feature = From Action
-_UI_DocumentRoot_fromOutcome_feature = From Outcome
-_UI_DocumentRoot_fromViewId_feature = From View Id
-_UI_DocumentRoot_icon_feature = Icon
-_UI_DocumentRoot_key_feature = Key
-_UI_DocumentRoot_keyClass_feature = Key Class
-_UI_DocumentRoot_largeIcon_feature = Large Icon
-_UI_DocumentRoot_lifecycle_feature = Lifecycle
-_UI_DocumentRoot_lifecycleFactory_feature = Lifecycle Factory
-_UI_DocumentRoot_listEntries_feature = List Entries
-_UI_DocumentRoot_localeConfig_feature = Locale Config
-_UI_DocumentRoot_managedBean_feature = Managed Bean
-_UI_DocumentRoot_managedBeanClass_feature = Managed Bean Class
-_UI_DocumentRoot_managedBeanName_feature = Managed Bean Name
-_UI_DocumentRoot_managedBeanScope_feature = Managed Bean Scope
-_UI_DocumentRoot_managedProperty_feature = Managed Property
-_UI_DocumentRoot_mapEntries_feature = Map Entries
-_UI_DocumentRoot_mapEntry_feature = Map Entry
-_UI_DocumentRoot_messageBundle_feature = Message Bundle
-_UI_DocumentRoot_navigationCase_feature = Navigation Case
-_UI_DocumentRoot_navigationHandler_feature = Navigation Handler
-_UI_DocumentRoot_navigationRule_feature = Navigation Rule
-_UI_DocumentRoot_nullValue_feature = Null Value
-_UI_DocumentRoot_phaseListener_feature = Phase Listener
-_UI_DocumentRoot_property_feature = Property
-_UI_DocumentRoot_propertyClass_feature = Property Class
-_UI_DocumentRoot_propertyExtension_feature = Property Extension
-_UI_DocumentRoot_propertyName_feature = Property Name
-_UI_DocumentRoot_propertyResolver_feature = Property Resolver
-_UI_DocumentRoot_redirect_feature = Redirect
-_UI_DocumentRoot_referencedBean_feature = Referenced Bean
-_UI_DocumentRoot_referencedBeanClass_feature = Referenced Bean Class
-_UI_DocumentRoot_referencedBeanName_feature = Referenced Bean Name
-_UI_DocumentRoot_renderer_feature = Renderer
-_UI_DocumentRoot_rendererClass_feature = Renderer Class
-_UI_DocumentRoot_rendererExtension_feature = Renderer Extension
-_UI_DocumentRoot_rendererType_feature = Renderer Type
-_UI_DocumentRoot_renderKit_feature = Render Kit
-_UI_DocumentRoot_renderKitClass_feature = Render Kit Class
-_UI_DocumentRoot_renderKitFactory_feature = Render Kit Factory
-_UI_DocumentRoot_renderKitId_feature = Render Kit Id
-_UI_DocumentRoot_smallIcon_feature = Small Icon
-_UI_DocumentRoot_stateManager_feature = State Manager
-_UI_DocumentRoot_suggestedValue_feature = Suggested Value
-_UI_DocumentRoot_supportedLocale_feature = Supported Locale
-_UI_DocumentRoot_toViewId_feature = To View Id
-_UI_DocumentRoot_validator_feature = Validator
-_UI_DocumentRoot_validatorClass_feature = Validator Class
-_UI_DocumentRoot_validatorId_feature = Validator Id
-_UI_DocumentRoot_value_feature = Value
-_UI_DocumentRoot_valueClass_feature = Value Class
-_UI_DocumentRoot_variableResolver_feature = Variable Resolver
-_UI_DocumentRoot_viewHandler_feature = View Handler
-_UI_FacesConfigType_application_feature = Application
-_UI_FacesConfigType_factory_feature = Factory
-_UI_FacesConfigType_component_feature = Component
-_UI_FacesConfigType_converter_feature = Converter
-_UI_FacesConfigType_managedBean_feature = Managed Bean
-_UI_FacesConfigType_navigationRule_feature = Navigation Rule
-_UI_FacesConfigType_referencedBean_feature = Referenced Bean
-_UI_FacesConfigType_renderKit_feature = Render Kit
-_UI_FacesConfigType_lifecycle_feature = Lifecycle
-_UI_FacesConfigType_validator_feature = Validator
-_UI_FacesConfigType_xmlns_feature = Xmlns
-_UI_FacesConfigType_id_feature = Id
-_UI_FacesContextFactoryType_textContent_feature = Text Content
-_UI_FacesContextFactoryType_id_feature = Id
-_UI_FacetExtensionType_mixed_feature = Mixed
-_UI_FacetExtensionType_group_feature = Group
-_UI_FacetExtensionType_any_feature = Any
-_UI_FacetExtensionType_id_feature = Id
-_UI_FacetNameType_textContent_feature = Text Content
-_UI_FacetNameType_id_feature = Id
-_UI_FacetType_description_feature = Description
-_UI_FacetType_displayName_feature = Display Name
-_UI_FacetType_icon_feature = Icon
-_UI_FacetType_facetName_feature = Facet Name
-_UI_FacetType_facetExtension_feature = Facet Extension
-_UI_FacetType_id_feature = Id
-_UI_FactoryType_applicationFactory_feature = Application Factory
-_UI_FactoryType_facesContextFactory_feature = Faces Context Factory
-_UI_FactoryType_lifecycleFactory_feature = Lifecycle Factory
-_UI_FactoryType_renderKitFactory_feature = Render Kit Factory
-_UI_FactoryType_id_feature = Id
-_UI_FromActionType_textContent_feature = Text Content
-_UI_FromActionType_id_feature = Id
-_UI_FromOutcomeType_textContent_feature = Text Content
-_UI_FromOutcomeType_id_feature = Id
-_UI_FromViewIdType_textContent_feature = Text Content
-_UI_FromViewIdType_id_feature = Id
-_UI_IconType_smallIcon_feature = Small Icon
-_UI_IconType_largeIcon_feature = Large Icon
-_UI_IconType_lang_feature = Lang
-_UI_IconType_id_feature = Id
-_UI_KeyClassType_textContent_feature = Text Content
-_UI_KeyClassType_id_feature = Id
-_UI_KeyType_textContent_feature = Text Content
-_UI_KeyType_id_feature = Id
-_UI_LargeIconType_textContent_feature = Text Content
-_UI_LargeIconType_id_feature = Id
-_UI_LifecycleFactoryType_textContent_feature = Text Content
-_UI_LifecycleFactoryType_id_feature = Id
-_UI_LifecycleType_phaseListener_feature = Phase Listener
-_UI_LifecycleType_id_feature = Id
-_UI_ListEntriesType_valueClass_feature = Value Class
-_UI_ListEntriesType_nullValue_feature = Null Value
-_UI_ListEntriesType_value_feature = Value
-_UI_ListEntriesType_id_feature = Id
-_UI_LocaleConfigType_defaultLocale_feature = Default Locale
-_UI_LocaleConfigType_supportedLocale_feature = Supported Locale
-_UI_LocaleConfigType_id_feature = Id
-_UI_ManagedBeanClassType_textContent_feature = Text Content
-_UI_ManagedBeanClassType_id_feature = Id
-_UI_ManagedBeanNameType_textContent_feature = Text Content
-_UI_ManagedBeanNameType_id_feature = Id
-_UI_ManagedBeanScopeType_textContent_feature = Text Content
-_UI_ManagedBeanScopeType_id_feature = Id
-_UI_ManagedBeanType_description_feature = Description
-_UI_ManagedBeanType_displayName_feature = Display Name
-_UI_ManagedBeanType_icon_feature = Icon
-_UI_ManagedBeanType_managedBeanName_feature = Managed Bean Name
-_UI_ManagedBeanType_managedBeanClass_feature = Managed Bean Class
-_UI_ManagedBeanType_managedBeanScope_feature = Managed Bean Scope
-_UI_ManagedBeanType_managedProperty_feature = Managed Property
-_UI_ManagedBeanType_mapEntries_feature = Map Entries
-_UI_ManagedBeanType_listEntries_feature = List Entries
-_UI_ManagedBeanType_id_feature = Id
-_UI_ManagedPropertyType_description_feature = Description
-_UI_ManagedPropertyType_displayName_feature = Display Name
-_UI_ManagedPropertyType_icon_feature = Icon
-_UI_ManagedPropertyType_propertyName_feature = Property Name
-_UI_ManagedPropertyType_propertyClass_feature = Property Class
-_UI_ManagedPropertyType_mapEntries_feature = Map Entries
-_UI_ManagedPropertyType_nullValue_feature = Null Value
-_UI_ManagedPropertyType_value_feature = Value
-_UI_ManagedPropertyType_listEntries_feature = List Entries
-_UI_ManagedPropertyType_id_feature = Id
-_UI_MapEntriesType_keyClass_feature = Key Class
-_UI_MapEntriesType_valueClass_feature = Value Class
-_UI_MapEntriesType_mapEntry_feature = Map Entry
-_UI_MapEntriesType_id_feature = Id
-_UI_MapEntryType_key_feature = Key
-_UI_MapEntryType_nullValue_feature = Null Value
-_UI_MapEntryType_value_feature = Value
-_UI_MapEntryType_id_feature = Id
-_UI_MessageBundleType_textContent_feature = Text Content
-_UI_MessageBundleType_id_feature = Id
-_UI_NavigationCaseType_description_feature = Description
-_UI_NavigationCaseType_displayName_feature = Display Name
-_UI_NavigationCaseType_icon_feature = Icon
-_UI_NavigationCaseType_fromAction_feature = From Action
-_UI_NavigationCaseType_fromOutcome_feature = From Outcome
-_UI_NavigationCaseType_toViewId_feature = To View Id
-_UI_NavigationCaseType_redirect_feature = Redirect
-_UI_NavigationCaseType_id_feature = Id
-_UI_NavigationHandlerType_textContent_feature = Text Content
-_UI_NavigationHandlerType_id_feature = Id
-_UI_NavigationRuleType_description_feature = Description
-_UI_NavigationRuleType_displayName_feature = Display Name
-_UI_NavigationRuleType_icon_feature = Icon
-_UI_NavigationRuleType_fromViewId_feature = From View Id
-_UI_NavigationRuleType_navigationCase_feature = Navigation Case
-_UI_NavigationRuleType_id_feature = Id
-_UI_NullValueType_id_feature = Id
-_UI_PhaseListenerType_textContent_feature = Text Content
-_UI_PhaseListenerType_id_feature = Id
-_UI_PropertyClassType_textContent_feature = Text Content
-_UI_PropertyClassType_id_feature = Id
-_UI_PropertyExtensionType_mixed_feature = Mixed
-_UI_PropertyExtensionType_group_feature = Group
-_UI_PropertyExtensionType_any_feature = Any
-_UI_PropertyExtensionType_id_feature = Id
-_UI_PropertyNameType_textContent_feature = Text Content
-_UI_PropertyNameType_id_feature = Id
-_UI_PropertyResolverType_textContent_feature = Text Content
-_UI_PropertyResolverType_id_feature = Id
-_UI_PropertyType_description_feature = Description
-_UI_PropertyType_displayName_feature = Display Name
-_UI_PropertyType_icon_feature = Icon
-_UI_PropertyType_propertyName_feature = Property Name
-_UI_PropertyType_propertyClass_feature = Property Class
-_UI_PropertyType_defaultValue_feature = Default Value
-_UI_PropertyType_suggestedValue_feature = Suggested Value
-_UI_PropertyType_propertyExtension_feature = Property Extension
-_UI_PropertyType_id_feature = Id
-_UI_RedirectType_id_feature = Id
-_UI_ReferencedBeanClassType_textContent_feature = Text Content
-_UI_ReferencedBeanClassType_id_feature = Id
-_UI_ReferencedBeanNameType_textContent_feature = Text Content
-_UI_ReferencedBeanNameType_id_feature = Id
-_UI_ReferencedBeanType_description_feature = Description
-_UI_ReferencedBeanType_displayName_feature = Display Name
-_UI_ReferencedBeanType_icon_feature = Icon
-_UI_ReferencedBeanType_referencedBeanName_feature = Referenced Bean Name
-_UI_ReferencedBeanType_referencedBeanClass_feature = Referenced Bean Class
-_UI_ReferencedBeanType_id_feature = Id
-_UI_RendererClassType_textContent_feature = Text Content
-_UI_RendererClassType_id_feature = Id
-_UI_RendererExtensionType_mixed_feature = Mixed
-_UI_RendererExtensionType_group_feature = Group
-_UI_RendererExtensionType_any_feature = Any
-_UI_RendererExtensionType_id_feature = Id
-_UI_RendererType_description_feature = Description
-_UI_RendererType_displayName_feature = Display Name
-_UI_RendererType_icon_feature = Icon
-_UI_RendererType_componentFamily_feature = Component Family
-_UI_RendererType_rendererType_feature = Renderer Type
-_UI_RendererType_rendererClass_feature = Renderer Class
-_UI_RendererType_facet_feature = Facet
-_UI_RendererType_attribute_feature = Attribute
-_UI_RendererType_rendererExtension_feature = Renderer Extension
-_UI_RendererType_id_feature = Id
-_UI_RendererTypeType_textContent_feature = Text Content
-_UI_RendererTypeType_id_feature = Id
-_UI_RenderKitClassType_textContent_feature = Text Content
-_UI_RenderKitClassType_id_feature = Id
-_UI_RenderKitFactoryType_textContent_feature = Text Content
-_UI_RenderKitFactoryType_id_feature = Id
-_UI_RenderKitIdType_textContent_feature = Text Content
-_UI_RenderKitIdType_id_feature = Id
-_UI_RenderKitType_description_feature = Description
-_UI_RenderKitType_displayName_feature = Display Name
-_UI_RenderKitType_icon_feature = Icon
-_UI_RenderKitType_renderKitId_feature = Render Kit Id
-_UI_RenderKitType_renderKitClass_feature = Render Kit Class
-_UI_RenderKitType_renderer_feature = Renderer
-_UI_RenderKitType_id_feature = Id
-_UI_SmallIconType_textContent_feature = Text Content
-_UI_SmallIconType_id_feature = Id
-_UI_StateManagerType_textContent_feature = Text Content
-_UI_StateManagerType_id_feature = Id
-_UI_SuggestedValueType_textContent_feature = Text Content
-_UI_SuggestedValueType_id_feature = Id
-_UI_SupportedLocaleType_textContent_feature = Text Content
-_UI_SupportedLocaleType_id_feature = Id
-_UI_ToViewIdType_textContent_feature = Text Content
-_UI_ToViewIdType_id_feature = Id
-_UI_ValidatorClassType_textContent_feature = Text Content
-_UI_ValidatorClassType_id_feature = Id
-pluginName = FacesConfig Model
-providerName = www.example.org
-_UI_DynamicElement_type = Dynamic Element
-_UI_ExtensionType_type = Extension Type
-_UI_DynamicElement_childNodes_feature = Child Nodes
-_UI_DynamicElement_attributes_feature = Attributes
-_UI_DynamicElement_name_feature = Name
-_UI_ValidatorIdType_textContent_feature = Text Content
-_UI_ValidatorIdType_id_feature = Id
-_UI_ValidatorType_description_feature = Description
-_UI_ValidatorType_displayName_feature = Display Name
-_UI_ValidatorType_icon_feature = Icon
-_UI_ValidatorType_validatorId_feature = Validator Id
-_UI_ValidatorType_validatorClass_feature = Validator Class
-_UI_ValidatorType_attribute_feature = Attribute
-_UI_ValidatorType_property_feature = Property
-_UI_ValidatorType_id_feature = Id
-_UI_ValueClassType_textContent_feature = Text Content
-_UI_ValueClassType_id_feature = Id
-_UI_ValueType_textContent_feature = Text Content
-_UI_ValueType_id_feature = Id
-_UI_VariableResolverType_textContent_feature = Text Content
-_UI_VariableResolverType_id_feature = Id
-_UI_ViewHandlerType_textContent_feature = Text Content
-_UI_ViewHandlerType_id_feature = Id
-_UI_ExtensionType_childNodes_feature = Child Nodes
-_UI_ExtensionType_textContent_feature = Text Content
-_UI_XMLTypeDocumentRoot_comment_feature = Comment
-_UI_XMLTypeDocumentRoot_text_feature = Text
-_UI_XMLTypeDocumentRoot_cDATA_feature = CDATA
-_UI_Unknown_feature = Unspecified
-
-_UI_DynamicAttribute_type = Dynamic Attribute
-_UI_DynamicAttribute_name_feature = Name
-_UI_DynamicAttribute_value_feature = Value
-_UI_DynamicElement_textContent_feature = Text Content
-_UI_ExtensionType_id_feature = Id
-_UI_ELResolverType_type = EL Resolver Type
-_UI_ResourceBundleType_type = Resource Bundle Type
-_UI_BaseNameType_type = Base Name Type
-_UI_VarType_type = Var Type
-_UI_ApplicationType_elResolver_feature = El Resolver
-_UI_ApplicationType_resourceBundle_feature = Resource Bundle
-_UI_ELResolverType_textContent_feature = Text Content
-_UI_ELResolverType_id_feature = Id
-_UI_ResourceBundleType_description_feature = Description
-_UI_ResourceBundleType_displayName_feature = Display Name
-_UI_ResourceBundleType_icon_feature = Icon
-_UI_ResourceBundleType_baseName_feature = Base Name
-_UI_ResourceBundleType_var_feature = Var
-_UI_ResourceBundleType_id_feature = Id
-_UI_BaseNameType_textContent_feature = Text Content
-_UI_BaseNameType_id_feature = Id
-_UI_VarType_textContent_feature = Text Content
-_UI_VarType_id_feature = Id
-_UI_ApplicationType_eLResolver_feature = EL Resolver
-_UI_ApplicationExtensionType_type = Application Extension Type
-_UI_ApplicationType_applicationExtension_feature = Application Extension
-_UI_ConverterExtensionType_type = Converter Extension Type
-_UI_FacesConfigExtensionType_type = Extension Type
-_UI_FactoryExtensionType_type = Factory Extension Type
-_UI_LifecycleExtensionType_type = Lifecycle Extension Type
-_UI_ManagedBeanExtensionType_type = Managed Bean Extension Type
-_UI_NavigationRuleExtensionType_type = Navigation Rule Extension Type
-_UI_ValidatorExtensionType_type = Validator Extension Type
-_UI_ConverterType_converterExtension_feature = Converter Extension
-_UI_FacesConfigType_facesConfigExtension_feature = Faces Config Extension
-_UI_FactoryType_factoryExtension_feature = Factory Extension
-_UI_LifecycleType_lifecycleExtension_feature = Lifecycle Extension
-_UI_ManagedBeanType_managedBeanExtension_feature = Managed Bean Extension
-_UI_NavigationRuleType_navigationRuleExtension_feature = Navigation Rule Extension
-_UI_ValidatorType_validatorExtension_feature = Validator Extension
-_UI_RenderKitExtensionType_type = Render Kit Extension Type
-_UI_RenderKitType_renderKitExtension_feature = Render Kit Extension
-_UI_XMLTypeDocumentRoot_processingInstruction_feature = Processing Instruction
-_UI_AbsoluteOrderingType_type = Absolute Ordering Type
-_UI_BehaviorClassType_type = Behavior Class Type
-_UI_BehaviorIdType_type = Behavior Id Type
-_UI_BehaviorType_type = Behavior Type
-_UI_BehaviorExtensionType_type = Behavior Extension Type
-_UI_ClientBehaviorRendererClassType_type = Client Behavior Renderer Class Type
-_UI_ClientBehaviorRendererType_type = Client Behavior Renderer Type
-_UI_ClientBehaviorRendererTypeType_type = Client Behavior Renderer Type Type
-_UI_DefaultValidatorsType_type = Default Validators Type
-_UI_ExceptionHandlerFactoryType_type = Exception Handler Factory Type
-_UI_ExternalContextFactoryType_type = External Context Factory Type
-_UI_IfType_type = If Type
-_UI_NameType_type = Name Type
-_UI_OrderingType_type = Ordering Type
-_UI_OrderingOrderingType_type = Ordering Ordering Type
-_UI_OrderingOthersType_type = Ordering Others Type
-_UI_PartialTraversalType_type = Partial Traversal Type
-_UI_PartialViewContextFactoryType_type = Partial View Context Factory Type
-_UI_RedirectViewParamType_type = Redirect View Param Type
-_UI_ResourceHandlerType_type = Resource Handler Type
-_UI_SourceClassType_type = Source Class Type
-_UI_SystemEventClassType_type = System Event Class Type
-_UI_SystemEventListenerClassType_type = System Event Listener Class Type
-_UI_SystemEventListenerType_type = System Event Listener Type
-_UI_TagHandlerDelegateFactoryType_type = Tag Handler Delegate Factory Type
-_UI_ViewDeclarationLanguageFactoryType_type = View Declaration Language Factory Type
-_UI_VisitContextFactoryType_type = Visit Context Factory Type
-_UI_AbsoluteOrderingType_id_feature = Id
-_UI_AbsoluteOrderingType_name_feature = Name
-_UI_AbsoluteOrderingType_others_feature = Others
-_UI_ApplicationType_partialTraversal_feature = Partial Traversal
-_UI_ApplicationType_resourceHandler_feature = Resource Handler
-_UI_ApplicationType_systemEventListener_feature = System Event Listener
-_UI_ApplicationType_defaultValidators_feature = Default Validators
-_UI_BehaviorClassType_textContent_feature = Text Content
-_UI_BehaviorClassType_id_feature = Id
-_UI_BehaviorIdType_textContent_feature = Text Content
-_UI_BehaviorIdType_id_feature = Id
-_UI_BehaviorType_description_feature = Description
-_UI_BehaviorType_displayName_feature = Display Name
-_UI_BehaviorType_icon_feature = Icon
-_UI_BehaviorType_behaviorId_feature = Behavior Id
-_UI_BehaviorType_behaviorClass_feature = Behavior Class
-_UI_BehaviorType_attribute_feature = Attribute
-_UI_BehaviorType_property_feature = Property
-_UI_BehaviorType_behaviorExtension_feature = Behavior Extension
-_UI_BehaviorType_id_feature = Id
-_UI_ClientBehaviorRendererClassType_textContent_feature = Text Content
-_UI_ClientBehaviorRendererClassType_id_feature = Id
-_UI_ClientBehaviorRendererType_clientBehaviorRendererType_feature = Client Behavior Renderer Type
-_UI_ClientBehaviorRendererType_clientBehaviorRendererClass_feature = Client Behavior Renderer Class
-_UI_ClientBehaviorRendererType_id_feature = Id
-_UI_ClientBehaviorRendererTypeType_textContent_feature = Text Content
-_UI_ClientBehaviorRendererTypeType_id_feature = Id
-_UI_DefaultValidatorsType_validatorId_feature = Validator Id
-_UI_DefaultValidatorsType_id_feature = Id
-_UI_DocumentRoot_absoluteOrdering_feature = Absolute Ordering
-_UI_DocumentRoot_behavior_feature = Behavior
-_UI_DocumentRoot_behaviorClass_feature = Behavior Class
-_UI_DocumentRoot_behaviorId_feature = Behavior Id
-_UI_DocumentRoot_behaviorExtension_feature = Behavior Extension
-_UI_DocumentRoot_defaultValidators_feature = Default Validators
-_UI_DocumentRoot_exceptionHandlerFactory_feature = Exception Handler Factory
-_UI_DocumentRoot_externalContextFactory_feature = External Context Factory
-_UI_DocumentRoot_if_feature = If
-_UI_DocumentRoot_name_feature = Name
-_UI_DocumentRoot_ordering_feature = Ordering
-_UI_DocumentRoot_orderingOrdering_feature = Ordering Ordering
-_UI_DocumentRoot_others_feature = Others
-_UI_DocumentRoot_partialTraversal_feature = Partial Traversal
-_UI_DocumentRoot_partialViewContextFactory_feature = Partial View Context Factory
-_UI_DocumentRoot_redirectViewParam_feature = Redirect View Param
-_UI_DocumentRoot_resourceHandler_feature = Resource Handler
-_UI_DocumentRoot_sourceClass_feature = Source Class
-_UI_DocumentRoot_systemEventClass_feature = System Event Class
-_UI_DocumentRoot_systemEventListener_feature = System Event Listener
-_UI_DocumentRoot_systemEventListenerClass_feature = System Event Listener Class
-_UI_DocumentRoot_tagHandlerDelegateFactory_feature = Tag Handler Delegate Factory
-_UI_DocumentRoot_viewDeclarationLanguageFactory_feature = View Declaration Language Factory
-_UI_DocumentRoot_visitContextFactory_feature = Visit Context Factory
-_UI_ExceptionHandlerFactoryType_textContent_feature = Text Content
-_UI_ExceptionHandlerFactoryType_id_feature = Id
-_UI_ExternalContextFactoryType_textContent_feature = Text Content
-_UI_ExternalContextFactoryType_id_feature = Id
-_UI_FacesConfigType_ordering_feature = Ordering
-_UI_FacesConfigType_absoluteOrdering_feature = Absolute Ordering
-_UI_FacesConfigType_name_feature = Name
-_UI_FacesConfigType_behavior_feature = Behavior
-_UI_FacesConfigType_metadataComplete_feature = Metadata Complete
-_UI_FactoryType_exceptionHandlerFactory_feature = Exception Handler Factory
-_UI_FactoryType_externalContextFactory_feature = External Context Factory
-_UI_FactoryType_partialViewContextFactory_feature = Partial View Context Factory
-_UI_FactoryType_viewDeclarationLanguageFactory_feature = View Declaration Language Factory
-_UI_FactoryType_tagHandlerDelegateFactory_feature = Tag Handler Delegate Factory
-_UI_FactoryType_visitContextFactory_feature = Visit Context Factory
-_UI_IfType_textContent_feature = Text Content
-_UI_IfType_id_feature = Id
-_UI_ManagedBeanType_eager_feature = Eager
-_UI_NameType_textContent_feature = Text Content
-_UI_NameType_id_feature = Id
-_UI_NavigationCaseType_if_feature = If
-_UI_OrderingType_id_feature = Id
-_UI_OrderingType_before_feature = Before
-_UI_OrderingType_after_feature = After
-_UI_OrderingOrderingType_id_feature = Id
-_UI_OrderingOrderingType_name_feature = Name
-_UI_OrderingOrderingType_others_feature = Others
-_UI_OrderingOthersType_id_feature = Id
-_UI_PartialTraversalType_textContent_feature = Text Content
-_UI_PartialTraversalType_id_feature = Id
-_UI_PartialViewContextFactoryType_textContent_feature = Text Content
-_UI_PartialViewContextFactoryType_id_feature = Id
-_UI_RedirectType_viewParam_feature = View Param
-_UI_RedirectType_includeViewParams_feature = Include View Params
-_UI_RedirectViewParamType_name_feature = Name
-_UI_RedirectViewParamType_value_feature = Value
-_UI_RedirectViewParamType_id_feature = Id
-_UI_RenderKitType_clientBehaviorRenderer_feature = Client Behavior Renderer
-_UI_ResourceHandlerType_textContent_feature = Text Content
-_UI_ResourceHandlerType_id_feature = Id
-_UI_SourceClassType_textContent_feature = Text Content
-_UI_SourceClassType_id_feature = Id
-_UI_SystemEventClassType_textContent_feature = Text Content
-_UI_SystemEventClassType_id_feature = Id
-_UI_SystemEventListenerClassType_textContent_feature = Text Content
-_UI_SystemEventListenerClassType_id_feature = Id
-_UI_SystemEventListenerType_systemEventListenerClass_feature = System Event Listener Class
-_UI_SystemEventListenerType_systemEventClass_feature = System Event Class
-_UI_SystemEventListenerType_sourceClass_feature = Source Class
-_UI_SystemEventListenerType_id_feature = Id
-_UI_TagHandlerDelegateFactoryType_textContent_feature = Text Content
-_UI_TagHandlerDelegateFactoryType_id_feature = Id
-_UI_ViewDeclarationLanguageFactoryType_textContent_feature = Text Content
-_UI_ViewDeclarationLanguageFactoryType_id_feature = Id
-_UI_VisitContextFactoryType_textContent_feature = Text Content
-_UI_VisitContextFactoryType_id_feature = Id
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/plugin.xml b/jsf/plugins/org.eclipse.jst.jsf.facesconfig/plugin.xml
deleted file mode 100644
index 41304d2..0000000
--- a/jsf/plugins/org.eclipse.jst.jsf.facesconfig/plugin.xml
+++ /dev/null
@@ -1,37 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?eclipse version="3.0"?>
-<plugin>
-   <extension 
-      point="org.eclipse.core.contenttype.contentTypes"> 
-      <content-type  
-         id="org.eclipse.jst.jsf.facesconfig.facesConfigFile" 
-         name="%facesconfig.name" 
-         base-type="org.eclipse.core.runtime.xml" 
-         file-extensions="xml"
-         priority="high"> 
-         <describer 
-            class="org.eclipse.core.runtime.content.XMLRootElementContentDescriber"> 
-            <parameter name="element" value="faces-config" /> 
-         </describer> 
-      </content-type> 
-   </extension>
-  <extension point="org.eclipse.emf.edit.itemProviderAdapterFactories">
-    <factory 
-       uri = "http://www.eclipse.org/webtools/jsf/schema/facesconfig.xsd" 
-       class = "org.eclipse.jst.jsf.facesconfig.edit.provider.FacesConfigItemProviderAdapterFactory" 
-       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>
-  <extension
-        point="org.eclipse.wst.common.emfworkbench.integration.editModel">
-     <editModel
-           editModelID="jsf.facesconfig"
-           factoryClass="org.eclipse.jst.common.jdt.internal.integration.JavaArtifactEditModelFactory">
-     </editModel>
-  </extension>
-
-</plugin>
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/.classpath b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/.classpath
deleted file mode 100644
index 304e861..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/.classpath
+++ /dev/null
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
-	<classpathentry kind="output" path="bin"/>
-</classpath>
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/.cvsignore b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/.cvsignore
deleted file mode 100644
index f9eb27a..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/.cvsignore
+++ /dev/null
@@ -1,3 +0,0 @@
-build.xml
-@dot
-javaCompiler...args
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/.project b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/.project
deleted file mode 100644
index 9685725..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/.project
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>org.eclipse.jst.pagedesigner.jsp.core</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/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/.settings/org.eclipse.core.resources.prefs b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/.settings/org.eclipse.core.resources.prefs
deleted file mode 100644
index 1c9084e..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/.settings/org.eclipse.core.resources.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Sun May 27 16:05:25 EDT 2007
-eclipse.preferences.version=1
-encoding/<project>=ISO-8859-1
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/.settings/org.eclipse.jdt.core.prefs b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/.settings/org.eclipse.jdt.core.prefs
deleted file mode 100644
index d8bc1cd..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/.settings/org.eclipse.jdt.core.prefs
+++ /dev/null
@@ -1,82 +0,0 @@
-#Mon Jun 30 15:58:19 PDT 2008
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
-org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.5
-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.doc.comment.support=enabled
-org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.autoboxing=warning
-org.eclipse.jdt.core.compiler.problem.deprecation=warning
-org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
-org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
-org.eclipse.jdt.core.compiler.problem.discouragedReference=ignore
-org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore
-org.eclipse.jdt.core.compiler.problem.fatalOptionalError=enabled
-org.eclipse.jdt.core.compiler.problem.fieldHiding=warning
-org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
-org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
-org.eclipse.jdt.core.compiler.problem.forbiddenReference=error
-org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
-org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
-org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=warning
-org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
-org.eclipse.jdt.core.compiler.problem.invalidJavadoc=error
-org.eclipse.jdt.core.compiler.problem.invalidJavadocTags=enabled
-org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef=disabled
-org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef=disabled
-org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=protected
-org.eclipse.jdt.core.compiler.problem.localVariableHiding=warning
-org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
-org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingJavadocComments=warning
-org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=protected
-org.eclipse.jdt.core.compiler.problem.missingJavadocTags=warning
-org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=protected
-org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore
-org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning
-org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
-org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
-org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=error
-org.eclipse.jdt.core.compiler.problem.nullReference=ignore
-org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
-org.eclipse.jdt.core.compiler.problem.parameterAssignment=ignore
-org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=warning
-org.eclipse.jdt.core.compiler.problem.potentialNullReference=ignore
-org.eclipse.jdt.core.compiler.problem.rawTypeReference=ignore
-org.eclipse.jdt.core.compiler.problem.redundantNullCheck=ignore
-org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=ignore
-org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
-org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
-org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled
-org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
-org.eclipse.jdt.core.compiler.problem.typeParameterHiding=ignore
-org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=ignore
-org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=error
-org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning
-org.eclipse.jdt.core.compiler.problem.unnecessaryElse=warning
-org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=warning
-org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=warning
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable=enabled
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference=enabled
-org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
-org.eclipse.jdt.core.compiler.problem.unusedImport=error
-org.eclipse.jdt.core.compiler.problem.unusedLabel=warning
-org.eclipse.jdt.core.compiler.problem.unusedLocal=error
-org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
-org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference=enabled
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
-org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
-org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=error
-org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
-org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.compiler.source=1.5
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/.settings/org.eclipse.jdt.ui.prefs b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/.settings/org.eclipse.jdt.ui.prefs
deleted file mode 100644
index 82eb6c1..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/.settings/org.eclipse.jdt.ui.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-#Fri Apr 06 18:25:15 PDT 2007
-eclipse.preferences.version=1
-org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><templates/>
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/.settings/org.eclipse.pde.prefs b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/.settings/org.eclipse.pde.prefs
deleted file mode 100644
index 851c0c3..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/.settings/org.eclipse.pde.prefs
+++ /dev/null
@@ -1,22 +0,0 @@
-#Fri May 30 12:00:06 PDT 2008
-compilers.f.unresolved-features=1
-compilers.f.unresolved-plugins=1
-compilers.incompatible-environment=1
-compilers.p.build=1
-compilers.p.deprecated=1
-compilers.p.discouraged-class=1
-compilers.p.internal=1
-compilers.p.missing-packages=0
-compilers.p.no-required-att=0
-compilers.p.not-externalized-att=0
-compilers.p.unknown-attribute=1
-compilers.p.unknown-class=1
-compilers.p.unknown-element=1
-compilers.p.unknown-identifier=1
-compilers.p.unknown-resource=1
-compilers.p.unresolved-ex-points=0
-compilers.p.unresolved-import=0
-compilers.s.create-docs=false
-compilers.s.doc-folder=doc
-compilers.s.open-tags=1
-eclipse.preferences.version=1
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/META-INF/MANIFEST.MF b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/META-INF/MANIFEST.MF
deleted file mode 100644
index 6a5feed..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,33 +0,0 @@
-Manifest-Version: 1.0
-Bundle-Name: %pluginName
-Bundle-SymbolicName: org.eclipse.jst.pagedesigner.jsp.core;singleton:=true
-Bundle-Version: 1.2.0.qualifier
-Bundle-ClassPath: .
-Bundle-Activator: org.eclipse.jst.pagedesigner.jsp.core.JSPCorePlugin
-Bundle-Vendor: %providerName
-Bundle-Localization: plugin
-Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.2.0,4.0.0)",
- org.eclipse.core.resources;bundle-version="[3.2.0,4.0.0)",
- org.eclipse.wst.sse.core;bundle-version="[1.1.0,1.2.0)",
- org.eclipse.wst.xml.core;bundle-version="[1.1.0,1.2.0)",
- org.eclipse.jst.jsp.core;bundle-version="[1.1.0,1.3.0)",
- org.eclipse.wst.html.core;bundle-version="[1.1.0,1.2.0)",
- org.eclipse.jst.jsf.common;bundle-version="[1.0.0,2.0.0)"
-Bundle-ActivationPolicy: lazy
-Bundle-ManifestVersion: 2
-Export-Package: org.eclipse.jst.pagedesigner.jsp.core;x-internal:=true,
- org.eclipse.jst.pagedesigner.jsp.core.el;x-internal:=true,
- org.eclipse.jst.pagedesigner.jsp.core.internal.pagevar;x-internal:=true,
- org.eclipse.jst.pagedesigner.jsp.core.pagevar;x-internal:=true,
- org.eclipse.jst.pagedesigner.jsp.core.pagevar.adapter;x-internal:=true,
- org.eclipse.jst.pagedesigner.jsp.core.util;x-internal:=true
-Bundle-RequiredExecutionEnvironment: J2SE-1.5
-Import-Package: javax.servlet;version="2.4.0",
- javax.servlet.http;version="2.4.0",
- javax.servlet.jsp;version="2.0.0",
- javax.servlet.jsp.el;version="2.0.0",
- javax.servlet.jsp.resources;version="2.0.0",
- javax.servlet.jsp.tagext;version="2.0.0",
- javax.servlet.resources;version="2.4.0",
- org.apache.commons.el;version="1.0.0",
- org.apache.commons.el.parser;version="1.0.0"
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/about.html b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/about.html
deleted file mode 100644
index 90bd74d..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/about.html
+++ /dev/null
@@ -1,22 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<html>
-<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>June, 2008</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 1.0 (&quot;EPL&quot;).  A copy of the EPL is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</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.</p>
-
-</body>
-</html>
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/build.properties b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/build.properties
deleted file mode 100644
index 6429d84..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/build.properties
+++ /dev/null
@@ -1,20 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2008 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-source.. = src/
-output.. = bin/
-bin.includes = plugin.xml,\
-               META-INF/,\
-               .,\
-               schema/,\
-               about.html,\
-               plugin.properties\                         
-javacSource=1.5
-javacTarget=1.5
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/plugin.properties b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/plugin.properties
deleted file mode 100644
index 3c3f9a1..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/plugin.properties
+++ /dev/null
@@ -1,17 +0,0 @@
-###############################################################################
-# Copyright (c) 2001, 2007 Oracle Corporation and others.
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
-# which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
-# 
-# Contributors:
-#     Oracle Corporation - initial API and implementation
-###############################################################################
-####################################################
-# Plugin XML information.
-####################################################
-pluginName=JavaServer Faces Tools - JSP Core Pagedesigner
-providerName=Eclipse.org
-
-extension-point.name.0 = page variable
\ No newline at end of file
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/plugin.xml b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/plugin.xml
deleted file mode 100644
index ea261e8..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/plugin.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?eclipse version="3.0"?>
-<plugin>
-   <extension-point id="pageVar" name="%extension-point.name.0" schema="schema/pageVar.exsd"/>
-</plugin>
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/schema/pageVar.exsd b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/schema/pageVar.exsd
deleted file mode 100644
index 962bf34..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/schema/pageVar.exsd
+++ /dev/null
@@ -1,172 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!-- Schema file written by PDE -->
-<schema targetNamespace="org.eclipse.jst.pagedesigner.jsp.core">
-<annotation>
-      <appInfo>
-         <meta.schema plugin="org.eclipse.jst.pagedesigner.jsp.core" id="pageVar" name="page variable"/>
-      </appInfo>
-      <documentation>
-         [Enter description of this extension point.]
-      </documentation>
-   </annotation>
-
-   <element name="extension">
-      <complexType>
-         <sequence>
-            <element ref="taglib" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="point" type="string" use="required">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="id" type="string">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="name" type="string">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="tag">
-      <complexType>
-         <attribute name="varName" type="string" use="required">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="varTypeMode" use="required">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-            <simpleType>
-               <restriction base="string">
-                  <enumeration value="CLASSNAME">
-                  </enumeration>
-                  <enumeration value="EXPRESSION">
-                  </enumeration>
-                  <enumeration value="EXPRESSION_COLLECTION_ITEM">
-                  </enumeration>
-                  <enumeration value="BUNDLE">
-                  </enumeration>
-               </restriction>
-            </simpleType>
-         </attribute>
-         <attribute name="varTypeString" type="string">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="varNameIsAttr" type="boolean" use="default" value="true">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="varTypeStringIsAttr" type="boolean" use="default" value="true">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-         <attribute name="tagName" type="string" use="required">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <element name="taglib">
-      <complexType>
-         <sequence>
-            <element ref="tag" minOccurs="0" maxOccurs="unbounded"/>
-         </sequence>
-         <attribute name="uri" type="string" use="required">
-            <annotation>
-               <documentation>
-                  
-               </documentation>
-            </annotation>
-         </attribute>
-      </complexType>
-   </element>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="since"/>
-      </appInfo>
-      <documentation>
-         [Enter the first release in which this extension point appears.]
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="examples"/>
-      </appInfo>
-      <documentation>
-         [Enter extension point usage example here.]
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="apiInfo"/>
-      </appInfo>
-      <documentation>
-         [Enter API information here.]
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="implementation"/>
-      </appInfo>
-      <documentation>
-         [Enter information about supplied implementation of this extension point.]
-      </documentation>
-   </annotation>
-
-   <annotation>
-      <appInfo>
-         <meta.section type="copyright"/>
-      </appInfo>
-      <documentation>
-         /*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-
-      </documentation>
-   </annotation>
-
-</schema>
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/IJSPCoreConstants.java b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/IJSPCoreConstants.java
deleted file mode 100644
index a628e6a..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/IJSPCoreConstants.java
+++ /dev/null
@@ -1,284 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.pagedesigner.jsp.core;
-
-/**
- * @author mengbo
- * @version 1.5
- */
-public interface IJSPCoreConstants 
-{
-    /**
-     * JSP tag name
-     */
-    final static public String TAG_ATTRIBUTE = "attribute"; //$NON-NLS-1$
-
-    /**
-     * JSP tag name
-     */
-	final static public String TAG_BODY = "body"; //$NON-NLS-1$
-
-    /**
-     * JSP tag name
-     */
-	final static public String TAG_ELEMENT = "element"; //$NON-NLS-1$
-
-    /**
-     * JSP tag name
-     */
-	final static public String TAG_EXPRESSION = "expression"; //$NON-NLS-1$
-
-    /**
-     * JSP tag name
-     */
-	final static public String TAG_DECLARATION = "declaration"; //$NON-NLS-1$
-
-    /**
-     * JSP tag name
-     */
-	final static public String TAG_DIRECTIVE_INCLUDE = "directive.include"; //$NON-NLS-1$
-
-    /**
-     * JSP tag name
-     */
-	final static public String TAG_DIRECTIVE_PAGE = "directive.page"; //$NON-NLS-1$
-
-    /**
-     * JSP tag name
-     */
-	final static public String TAG_DIRECTIVE_TAGLIB = "directive.taglib"; //$NON-NLS-1$
-
-    /**
-     * JSP tag name
-     */
-	final static public String TAG_DOBODY = "doBody"; //$NON-NLS-1$
-
-    /**
-     * JSP tag name
-     */
-	final static public String TAG_FORWARD = "forward"; //$NON-NLS-1$
-
-    /**
-     * JSP tag name
-     */
-	final static public String TAG_GETPROPERTY = "getProperty"; //$NON-NLS-1$
-
-    /**
-     * JSP tag name
-     */
-	final static public String TAG_INCLUDE = "include"; //$NON-NLS-1$
-
-    /**
-     * JSP tag name
-     */
-	final static public String TAG_INVOKE = "invoke"; //$NON-NLS-1$
-
-    /**
-     * JSP tag name
-     */
-	final static public String TAG_OUTPUT = "output"; //$NON-NLS-1$
-
-    /**
-     * JSP tag name
-     */
-	final static public String TAG_PLUGIN = "plugin"; //$NON-NLS-1$
-
-    /**
-     * JSP tag name
-     */
-	final static public String TAG_ROOT = "root"; //$NON-NLS-1$
-
-    /**
-     * JSP tag name
-     */
-	final static public String TAG_SCRIPTLET = "scriptlet"; //$NON-NLS-1$
-
-    /**
-     * JSP tag name
-     */
-	final static public String TAG_SETPROPERTY = "setProperty"; //$NON-NLS-1$
-
-    /**
-     * JSP tag name
-     */
-	final static public String TAG_TEXT = "text"; //$NON-NLS-1$
-
-    /**
-     * JSP tag name
-     */
-	final static public String TAG_USEBEAN = "useBean"; //$NON-NLS-1$
-
-    /**
-     * JSP tag name
-     */
-	final static public String TAG_LEADING_DIRECTIVE = "directive."; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_ALIGN = "align"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_ARCHIVE = "archive"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_BEANNAME = "beanName"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_CLASS = "class"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_CODE = "code"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_CODEBASE = "codebase"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_DOCTYPEROOTELEMENT = "doctype-root-element"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_DOCTYPESYSTEM = "doctype-system"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_DOCTYPEPUBLIC = "doctype-public"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_FILE = "file"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_FRAGMENT = "fragment"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_HEIGHT = "height"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_HSPACE = "hspace"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_ID = "id"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_IEPLUGINURL = "iepluginurl"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_JREVERSION = "jreversion"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_NAME = "name"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_NSPLUGINURL = "nspluginurl"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_OMITXMLDECLARATION = "omit-xml-declaration"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_PAGE = "page"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_PROPERTY = "property"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_SCOPE = "scope"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_TRIM = "trim"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_TYPE = "type"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_URI = "uri"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final public static String ATTR_TAGDIR = "tagdir"; //$NON-NLS-1$
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_VALUE = "value"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_VAR = "var"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_VARREADER = "varReader"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_VERSION = "version"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_XMLNSJSP = "xmlns:jsp"; //$NON-NLS-1$
-
-    /**
-     * JSP tag attribute name
-     */
-	final static public String ATTR_XMLNSTAGLIBPREFIX = "xmlns:taglibPrefix"; //$NON-NLS-1$
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/JSPCorePlugin.java b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/JSPCorePlugin.java
deleted file mode 100644
index 4ea9674..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/JSPCorePlugin.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.pagedesigner.jsp.core;
-
-import java.util.MissingResourceException;
-import java.util.ResourceBundle;
-
-import org.eclipse.core.runtime.Plugin;
-import org.osgi.framework.BundleContext;
-
-/**
- * The main plugin class to be used in the desktop.
- */
-public class JSPCorePlugin extends Plugin {
-	// The shared instance.
-	private static JSPCorePlugin plugin;
-
-	// Resource bundle.
-	private ResourceBundle resourceBundle;
-
-	/**
-	 * The constructor.
-	 */
-	public JSPCorePlugin() {
-		super();
-		plugin = this;
-		try {
-			resourceBundle = ResourceBundle
-					.getBundle("org.eclipse.jst.pagedesigner.jsp.core.JSPCorePluginResources"); //$NON-NLS-1$
-		} catch (MissingResourceException x) {
-			resourceBundle = null;
-		}
-	}
-
-	/**
-	 * This method is called upon plug-in activation
-	 */
-	public void start(BundleContext context) throws Exception {
-		super.start(context);
-	}
-
-	/**
-	 * This method is called when the plug-in is stopped
-	 */
-	public void stop(BundleContext context) throws Exception {
-		super.stop(context);
-	}
-
-	/**
-	 * Returns the shared instance.
-	 * @return the default plugin instance
-	 */
-	public static JSPCorePlugin getDefault() {
-		return plugin;
-	}
-
-	/**
-	 * Returns the string from the plugin's resource bundle, or 'key' if not
-	 * found.
-	 * @param key 
-	 * @return the string for key or 'key' if not found in the default resource bundle
-	 */
-	public static String getResourceString(String key) {
-		ResourceBundle bundle = JSPCorePlugin.getDefault().getResourceBundle();
-		try {
-			return (bundle != null) ? bundle.getString(key) : key;
-		} catch (MissingResourceException e) {
-			return key;
-		}
-	}
-
-	/**
-	 * Returns the plugin's resource bundle,
-	 * @return the resource bundle
-	 */
-	public ResourceBundle getResourceBundle() {
-		return resourceBundle;
-	}
-
-	/**
-	 * @return the plugin id
-	 */
-	public static String getPluginId() {
-		return getDefault().getBundle().getSymbolicName();
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/ListenerList.java b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/ListenerList.java
deleted file mode 100644
index 9596f97..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/ListenerList.java
+++ /dev/null
@@ -1,142 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.pagedesigner.jsp.core;
-
-/**
- * Local version of org.eclipse.jface.util.ListenerList (modified)
- * @author mengbo
- * @version 1.5
- */
-public class ListenerList {
-	/**
-	 * The current number of listeners. Maintains invariant: 0 <= fSize <=
-	 * listeners.length.
-	 */
-	private int _size;
-
-	/**
-	 * The list of listeners. Initially <code>null</code> but initialized to
-	 * an array of size capacity the first time a listener is added. Maintains
-	 * invariant: listeners != null if and only if fSize != 0
-	 */
-	private Object[] _listeners = null;
-
-	/**
-	 * The empty array singleton instance, returned by getListeners() when size ==
-	 * 0.
-	 */
-	private static final Object[] EmptyArray = new Object[0];
-
-	/**
-	 * Creates a listener list with the given initial capacity.
-	 * 
-	 * @param capacity
-	 *            the number of listeners which this list can initially accept
-	 *            without growing its internal representation; must be at least
-	 *            1
-	 */
-	public ListenerList(int capacity) {
-		if (capacity < 1) {
-			throw new IllegalArgumentException();
-		}
-		_listeners = new Object[capacity];
-		_size = 0;
-	}
-
-	/**
-	 * Adds a listener to the list. Has no effect if an identical listener is
-	 * already registered.
-	 * 
-	 * @param listener
-	 *            a listener
-	 */
-	public synchronized void add(Object listener) {
-		if (listener == null) {
-			throw new IllegalArgumentException();
-		}
-		// check for duplicates using identity
-		for (int i = 0; i < _size; ++i) {
-			if (_listeners[i] == listener) {
-				return;
-			}
-		}
-		// grow array if necessary
-		if (_size == _listeners.length) {
-			Object[] temp = new Object[(_size * 2) + 1];
-			System.arraycopy(_listeners, 0, temp, 0, _size);
-			_listeners = temp;
-		}
-		_listeners[_size++] = listener;
-	}
-
-	/**
-	 * Returns an array containing all the registered listeners. The resulting
-	 * array is unaffected by subsequent adds or removes. If there are no
-	 * listeners registered, the result is an empty array singleton instance (no
-	 * garbage is created). Use this method when notifying listeners, so that
-	 * any modifications to the listener list during the notification will have
-	 * no effect on the notification itself.
-	 * @return the array of registered listeners
-	 */
-	public synchronized Object[] getListeners() {
-		if (_size == 0) {
-			return EmptyArray;
-		}
-		Object[] result = new Object[_size];
-		System.arraycopy(_listeners, 0, result, 0, _size);
-		return result;
-	}
-
-	/**
-	 * Removes a listener from the list. Has no effect if an identical listener
-	 * was not already registered.
-	 * 
-	 * @param listener
-	 *            a listener
-	 */
-	public synchronized void remove(Object listener) {
-		if (listener == null) {
-			throw new IllegalArgumentException();
-		}
-
-		for (int i = 0; i < _size; ++i) {
-			if (_listeners[i] == listener) {
-				if (--_size == 0) {
-					_listeners = new Object[1];
-				} else {
-					if (i < _size) {
-						_listeners[i] = _listeners[_size];
-					}
-					_listeners[_size] = null;
-				}
-				return;
-			}
-		}
-	}
-
-	/**
-	 * Removes all the listeners from the list.
-	 */
-	public void removeAll() {
-		_listeners = new Object[0];
-		_size = 0;
-	}
-
-	/**
-	 * Returns the number of registered listeners
-	 * 
-	 * @return the number of registered listeners
-	 */
-	public int size() {
-		return _size;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/el/ELParser.java b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/el/ELParser.java
deleted file mode 100644
index 9c3ee7f..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/el/ELParser.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.pagedesigner.jsp.core.el;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.apache.commons.el.ComplexValue;
-import org.apache.commons.el.NamedValue;
-
-/**
- * 
- * @author mengbo
- * @version 1.5
- */
-public class ELParser {
-	private String _jsfExpression;
-
-	private List _expressionList;
-
-	/**
-	 * @param expression 
-	 * 
-	 */
-	public ELParser(String expression) {
-		super();
-		_jsfExpression = expression;
-		init();
-	}
-
-	/**
-	 * 
-	 */
-	private void init() {
-		Object parsedExpression = JSFELParserHelper
-				.parseExpression(_jsfExpression);
-
-		if (parsedExpression instanceof ComplexValue) {
-			_expressionList = new ArrayList();
-			_expressionList.add(((ComplexValue) parsedExpression).getPrefix());
-			_expressionList.addAll(((ComplexValue) parsedExpression)
-					.getSuffixes());
-		} else if (parsedExpression instanceof NamedValue) {
-			_expressionList = new ArrayList();
-			_expressionList.add(parsedExpression);
-		}
-
-	}
-
-	/**
-	 * @return the expression elements of null if none
-	 */
-	public Object[] getElements() {
-		if (_expressionList == null) {
-			return null;
-		}
-
-		return _expressionList.toArray();
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/el/JSFELParserHelper.java b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/el/JSFELParserHelper.java
deleted file mode 100644
index b8bca4e..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/el/JSFELParserHelper.java
+++ /dev/null
@@ -1,267 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.pagedesigner.jsp.core.el;
-
-import java.io.StringReader;
-
-import org.apache.commons.el.Expression;
-import org.apache.commons.el.ExpressionString;
-import org.apache.commons.el.parser.ELParser;
-import org.apache.commons.el.parser.ParseException;
-
-/**
- * Utility class to implement support functionality to "morph" JSP EL into JSF
- * EL
- * 
- * @author mengbo
- * @version 1.5
- */
-public final class JSFELParserHelper {
-	/**
-	 * an EL left brace
-	 */
-	public static String JSF_EL_LEFT_BRACE = "#{"; //$NON-NLS-1$
-
-	/**
-	 * an EL right brace
-	 */
-	public static String JSF_EL_RIGHT_BRACE = "}"; //$NON-NLS-1$
-
-	private JSFELParserHelper() {
-		// util class, do not instantiate
-	}
-
-	/**
-	 * Gets the parsed form of the given expression string. Returns either an
-	 * Expression or ExpressionString.
-	 * @param expressionString 
-	 * @return the result of parsing expressionString
-	 */
-	public static Object parseExpression(String expressionString) {
-		expressionString = toJspElExpression(expressionString);
-
-		ELParser parser = new ELParser(new StringReader(expressionString));
-		try {
-			Object expression = parser.ExpressionString();
-			if (!(expression instanceof Expression)
-					&& !(expression instanceof ExpressionString)) {
-				return null;
-			}
-
-			return expression;
-		} catch (ParseException e) {
-
-			// String msg = "Invalid expression: '" + expressionString + "'";
-			// log.debug(msg, e);
-			// throw new ReferenceSyntaxException(msg, e);
-		}
-		return null;
-	}
-
-	/**
-	 * @param expressionString
-	 * @return true if the expression is 'valid'
-	 */
-	public static boolean isValidEL(String expressionString) {
-		if (expressionString == null || expressionString.length() == 0) {
-			return false;
-		}
-
-		return expressionString.startsWith(JSF_EL_LEFT_BRACE)
-				&& expressionString.endsWith(JSF_EL_RIGHT_BRACE);
-	}
-
-	/**
-	 * @param expressionString
-	 * @return expressionString with the left and right braces removed
-	 * or the original string if isValidEL(expression) == false
-	 */
-	public static String trimELBrace(String expressionString) {
-		if (!isValidEL(expressionString)) {
-			return expressionString;
-		}
-		String trimedExpression = null;
-
-		trimedExpression = expressionString.substring(JSF_EL_LEFT_BRACE
-				.length(), expressionString.length()
-				- JSF_EL_RIGHT_BRACE.length());
-
-		return trimedExpression;
-	}
-
-	/**
-	 * Convert ValueBinding syntax #{ } to JSP EL syntax ${ }
-	 * 
-	 * @param expressionString
-	 *            <code>ValueBinding</code> reference expression
-	 * 
-	 * @return JSP EL compatible expression
-	 */
-	public static String toJspElExpression(String expressionString) {
-		StringBuffer sb = new StringBuffer(expressionString.length());
-		int remainsPos = 0;
-
-		for (int posOpenBrace = expressionString.indexOf('{'); posOpenBrace >= 0; posOpenBrace = expressionString
-				.indexOf('{', remainsPos)) {
-			if (posOpenBrace > 0) {
-				if (posOpenBrace - 1 > remainsPos)
-					sb.append(expressionString.substring(remainsPos,
-							posOpenBrace - 1));
-
-				if (expressionString.charAt(posOpenBrace - 1) == '$') {
-					sb.append("${'${'}"); //$NON-NLS-1$
-					remainsPos = posOpenBrace + 1;
-					continue;
-				} else if (expressionString.charAt(posOpenBrace - 1) == '#') {
-					// TODO: should use \\ as escape for \ always, not just when
-					// before #{
-					// allow use of '\' as escape symbol for #{ (for
-					// compatibility with Sun's extended implementation)
-					/*
-					 * if (isEscaped(expressionString, posOpenBrace - 1)) {
-					 * escapes: { for (int i = sb.length() - 1; i >= 0; i--) {
-					 * if (sb.charAt(i) != '\\') { sb.setLength( sb.length() -
-					 * (sb.length() - i) / 2); break escapes; } }
-					 * sb.setLength(sb.length() / 2); } sb.append("#{"); } else {
-					 */
-					sb.append("${"); //$NON-NLS-1$
-					int posCloseBrace = indexOfMatchingClosingBrace(
-							expressionString, posOpenBrace);
-					sb.append(expressionString.substring(posOpenBrace + 1,
-							posCloseBrace + 1));
-					remainsPos = posCloseBrace + 1;
-					continue;
-					// }
-				} else {
-					if (posOpenBrace > remainsPos)
-						sb.append(expressionString.charAt(posOpenBrace - 1));
-				}
-			}
-
-			// Standalone brace
-			sb.append('{');
-			remainsPos = posOpenBrace + 1;
-		}
-
-		sb.append(expressionString.substring(remainsPos));
-
-		// Create a new String to shrink mem size since we are caching
-		return new String(sb.toString());
-	}
-
-	private static int findQuote(String expressionString, int start) {
-		int indexofSingleQuote = expressionString.indexOf('\'', start);
-		int indexofDoubleQuote = expressionString.indexOf('"', start);
-		return minIndex(indexofSingleQuote, indexofDoubleQuote);
-	}
-
-	/**
-	 * Return the index of the matching closing brace, skipping over quoted text
-	 * 
-	 * @param expressionString
-	 *            string to search
-	 * @param indexofOpeningBrace
-	 *            the location of opening brace to match
-	 * 
-	 * @return the index of the matching closing brace
-	 * 
-	 * @throws ReferenceSyntaxException
-	 *             if matching brace cannot be found
-	 */
-	private static int indexOfMatchingClosingBrace(String expressionString,
-			int indexofOpeningBrace) {
-		int len = expressionString.length();
-		int i = indexofOpeningBrace + 1;
-
-		// Loop through quoted strings
-		for (;;) {
-			if (i >= len) {
-				throw new IllegalStateException(
-						"Missing closing brace. Expression: '" //$NON-NLS-1$
-								+ expressionString + "'"); //$NON-NLS-1$
-			}
-
-			int indexofClosingBrace = expressionString.indexOf('}', i);
-			i = minIndex(indexofClosingBrace, findQuote(expressionString, i));
-
-			if (i < 0) {
-				// No delimiter found
-				throw new IllegalStateException(
-						"Missing closing brace. Expression: '" //$NON-NLS-1$
-								+ expressionString + "'"); //$NON-NLS-1$
-			}
-
-			// 1. If quoted literal, find closing quote
-			if (i != indexofClosingBrace) {
-				i = indexOfMatchingClosingQuote(expressionString, i) + 1;
-				if (i == 0) {
-					// Note: if no match, i==0 because -1 + 1 = 0
-					throw new IllegalStateException(
-							"Missing closing quote. Expression: '" //$NON-NLS-1$
-									+ expressionString + "'"); //$NON-NLS-1$
-				}
-			} else {
-				// Closing brace
-				return i;
-			}
-		}
-	}
-
-	/**
-	 * Returns the index of the matching closing quote, skipping over escaped
-	 * quotes
-	 * 
-	 * @param expressionString
-	 *            string to scan
-	 * @param indexOfOpeningQuote
-	 *            start from this position in the string
-	 * @return -1 if no match, the index of closing quote otherwise
-	 */
-	private static int indexOfMatchingClosingQuote(String expressionString,
-			int indexOfOpeningQuote) {
-		char quote = expressionString.charAt(indexOfOpeningQuote);
-		for (int i = expressionString.indexOf(quote, indexOfOpeningQuote + 1); i >= 0; i = expressionString
-				.indexOf(quote, i + 1)) {
-			if (!isEscaped(expressionString, i)) {
-				return i;
-			}
-		}
-
-		// No matching quote found
-		return -1;
-	}
-
-	private static boolean isEscaped(String expressionString, int i) {
-		int escapeCharCount = 0;
-		while ((--i >= 0) && (expressionString.charAt(i) == '\\')) {
-			escapeCharCount++;
-		}
-
-		return (escapeCharCount % 2) != 0;
-	}
-
-	/**
-	 * Returns the minimum index >= 0, if any
-	 * 
-	 * <p>
-	 * Use to find the first of two characters in a string:<br>
-	 * <code>minIndex(s.indexOf('/'), indexOf('\'))</code>
-	 * </p>
-	 * @param a 
-	 * @param b 
-	 * @return the minimum index >= 0, if any
-	 * 
-	 */
-	public static int minIndex(int a, int b) {
-		return (a < 0) ? b : (b < 0) ? a : (a < b) ? a : b;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/internal/pagevar/DocumentPageVariableAdapter.java b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/internal/pagevar/DocumentPageVariableAdapter.java
deleted file mode 100644
index ebd93fe..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/internal/pagevar/DocumentPageVariableAdapter.java
+++ /dev/null
@@ -1,212 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.pagedesigner.jsp.core.internal.pagevar;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.eclipse.jst.pagedesigner.jsp.core.ListenerList;
-import org.eclipse.jst.pagedesigner.jsp.core.pagevar.IChangeListener;
-import org.eclipse.jst.pagedesigner.jsp.core.pagevar.IVariableInfo;
-import org.eclipse.jst.pagedesigner.jsp.core.pagevar.adapter.IDocumentPageVariableAdapter;
-import org.eclipse.jst.pagedesigner.jsp.core.pagevar.adapter.IPageVariableAdapter;
-import org.eclipse.wst.sse.core.internal.provisional.INodeNotifier;
-import org.eclipse.wst.xml.core.internal.provisional.document.IDOMDocument;
-import org.w3c.dom.Element;
-import org.w3c.dom.Node;
-import org.w3c.dom.NodeList;
-
-/**
- * This adapter will be adapted on the JSP document.
- * 
- * @author mengbo
- * @version 1.5
- */
-public class DocumentPageVariableAdapter implements
-		IDocumentPageVariableAdapter {
-	private IDOMDocument _document;
-
-	private ListenerList _changeListeners = new ListenerList(2);
-
-	private List _variableInfos = new ArrayList();
-
-	private boolean _readingInfo = false;
-
-	/**
-	 * @param doc 
-	 * 
-	 */
-	public DocumentPageVariableAdapter(IDOMDocument doc) {
-		super();
-		this._document = doc;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.pagedesigner.jsp.core.pagevar.IPageVariablesProvider#getBeanInfos()
-	 */
-	public IVariableInfo[] getBeanInfos() {
-		IVariableInfo[] ret = new IVariableInfo[_variableInfos.size()];
-		return (IVariableInfo[]) _variableInfos.toArray(ret);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.pagedesigner.jsp.core.pagevar.IPageVariablesProvider#addChangeListener(org.eclipse.jst.pagedesigner.jsp.core.pagevar.IChangeListener)
-	 */
-	public void addChangeListener(IChangeListener listener) {
-		this.reReadInfo();
-		_changeListeners.add(listener);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.pagedesigner.jsp.core.pagevar.IPageVariablesProvider#removeChangeListener(org.eclipse.jst.pagedesigner.jsp.core.pagevar.IChangeListener)
-	 */
-	public void removeChangeListener(IChangeListener listener) {
-		_changeListeners.remove(listener);
-	}
-
-	/**
-	 * fire change events on all listeners
-	 */
-	protected void fireChanged() {
-		Object[] listeners = _changeListeners.getListeners();
-		for (int i = 0; i < listeners.length; i++) {
-			IChangeListener l = (IChangeListener) listeners[i];
-			l.changed();
-		}
-
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.wst.sse.core.internal.provisional.INodeAdapter#isAdapterForType(java.lang.Object)
-	 */
-	public boolean isAdapterForType(Object type) {
-		return IDocumentPageVariableAdapter.class.equals(type);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.wst.sse.core.internal.provisional.INodeAdapter#notifyChanged(org.eclipse.wst.sse.core.internal.provisional.INodeNotifier,
-	 *      int, java.lang.Object, java.lang.Object, java.lang.Object, int)
-	 */
-	public void notifyChanged(INodeNotifier notifier, int eventType,
-			Object changedFeature, Object oldValue, Object newValue, int pos) {
-		switch (eventType) {
-		case INodeNotifier.STRUCTURE_CHANGED:
-		case INodeNotifier.CONTENT_CHANGED:
-		case INodeNotifier.CHANGE:
-			refresh();
-			break;
-		default:
-			// skip. Ignore other kinds of change.
-		}
-
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.pagedesigner.jsp.core.pagevar.IPageVariablesProvider#refresh()
-	 */
-	public void refresh() {
-		reReadInfo();
-	}
-
-	/**
-	 * re-read page variable info
-	 */
-	protected void reReadInfo() {
-		if (this._readingInfo) {
-			return;
-		}
-		try {
-			List oldInfo = this._variableInfos;
-			this._variableInfos = new ArrayList();
-			readNode(_document);
-			if (!isSame(oldInfo, this._variableInfos)) {
-				fireChanged();
-			}
-		} finally {
-			this._readingInfo = false;
-		}
-	}
-
-	/**
-	 * compare two variable info list.
-	 * 
-	 * @param oldInfo
-	 * @param list
-	 * @return true if same.
-	 */
-	private boolean isSame(List oldInfo, List list) {
-		if (oldInfo.size() != list.size()) {
-			return false;
-		}
-		for (int i = 0, size = oldInfo.size(); i < size; i++) {
-			IVariableInfo info1 = (IVariableInfo) oldInfo.get(i);
-			IVariableInfo info2 = (IVariableInfo) list.get(i);
-			if (info1 == null) {
-				return false;// should not happen
-			}
-			if (!info1.equals(info2)) {
-				return false;
-			}
-		}
-		return true;
-	}
-
-	/**
-	 * recursively read all element, and see whether they have
-	 * IPageVariableAdapter, and then get variable info.
-	 * 
-	 * @param element
-	 */
-	private void readNode(Node node) {
-		if (node instanceof INodeNotifier && node instanceof Element) {
-			Element element = (Element) node;
-			Object obj = ((INodeNotifier) element)
-					.getAdapterFor(IPageVariableAdapter.class);
-			if (obj instanceof IPageVariableAdapter) {
-				IPageVariableAdapter adapter = (IPageVariableAdapter) obj;
-				if (adapter.supportMultipleVariable(element)) {
-					List infos = ((IPageVariableAdapter) obj)
-							.getVariableInfos(element);
-					if (infos != null) {
-						this._variableInfos.addAll(infos);
-					}
-				} else {
-					// hope not doing addAll could improve some performance.
-					IVariableInfo info = adapter.getVariableInfo(element);
-					if (info != null) {
-						this._variableInfos.add(info);
-					}
-				}
-			}
-		}
-
-		NodeList childNodes = node.getChildNodes();
-		if (childNodes != null) {
-			for (int i = 0, length = childNodes.getLength(); i < length; i++) {
-				Node childNode = childNodes.item(i);
-				readNode(childNode);
-			}
-		}
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/internal/pagevar/PageVariableAdapter.java b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/internal/pagevar/PageVariableAdapter.java
deleted file mode 100644
index 40e01b5..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/internal/pagevar/PageVariableAdapter.java
+++ /dev/null
@@ -1,164 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.pagedesigner.jsp.core.internal.pagevar;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-import org.eclipse.jst.pagedesigner.jsp.core.pagevar.IVariableInfo;
-import org.eclipse.jst.pagedesigner.jsp.core.pagevar.adapter.IDocumentPageVariableAdapter;
-import org.eclipse.jst.pagedesigner.jsp.core.pagevar.adapter.IPageVariableAdapter;
-import org.eclipse.wst.sse.core.internal.provisional.INodeNotifier;
-import org.eclipse.wst.xml.core.internal.provisional.document.IDOMDocument;
-import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;
-import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
-import org.w3c.dom.Element;
-
-/**
- * @author mengbo
- * @version 1.5
- */
-public class PageVariableAdapter implements IPageVariableAdapter {
-	static final PageVariableAdapter _instance = new PageVariableAdapter();
-
-	/**
-	 * @return the singleton instance
-	 */
-	public static PageVariableAdapter getInstance() {
-		return _instance;
-	}
-
-	/**
-	 * no external instatiation
-	 */
-	private PageVariableAdapter() {
-		super();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.wst.sse.core.internal.provisional.INodeAdapter#isAdapterForType(java.lang.Object)
-	 */
-	public boolean isAdapterForType(Object type) {
-		return IPageVariableAdapter.class.equals(type);
-	}
-
-	private IDocumentPageVariableAdapter getDocumentAdapter(
-			INodeNotifier notifier) {
-		if (notifier instanceof IDOMNode) {
-			IDOMModel model = ((IDOMNode) notifier).getModel();
-			if (model != null) {
-				IDOMDocument document = model.getDocument();
-				if (document != null) {
-					return (IDocumentPageVariableAdapter) document
-							.getAdapterFor(IDocumentPageVariableAdapter.class);
-				}
-			}
-		}
-		return null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.wst.sse.core.internal.provisional.INodeAdapter#notifyChanged(org.eclipse.wst.sse.core.internal.provisional.INodeNotifier,
-	 *      int, java.lang.Object, java.lang.Object, java.lang.Object, int)
-	 */
-	public void notifyChanged(INodeNotifier notifier, int eventType,
-			Object changedFeature, Object oldValue, Object newValue, int pos) {
-		IDocumentPageVariableAdapter docadapter = getDocumentAdapter(notifier);
-
-		switch (eventType) {
-		case INodeNotifier.STRUCTURE_CHANGED:
-			docadapter.refresh();
-			break;
-		case INodeNotifier.CONTENT_CHANGED:
-		case INodeNotifier.CHANGE:
-			// only this node changed, only refresh if this node is page
-			// variable node
-			if (notifier instanceof Element
-					&& supportVariableInfo((Element) notifier)) {
-				docadapter.refresh();
-			}
-			break;
-		default:
-			// skip. Ignore other kinds of change.
-		}
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.pagedesigner.jsp.core.pagevar.adapter.IPageVariableAdapter#supportMultipleVariable(org.w3c.dom.Element)
-	 */
-	public boolean supportMultipleVariable(Element element) {
-		return false;
-	}
-
-	/**
-	 * @param element
-	 * @return
-	 */
-	private boolean supportVariableInfo(Element element) {
-		return PageVariableAdatperRegistry.getInstance().getTagVarDescriptor(
-				element) != null;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.pagedesigner.jsp.core.pagevar.adapter.IPageVariableAdapter#getVariableInfo(org.w3c.dom.Element)
-	 */
-	public IVariableInfo getVariableInfo(Element element) {
-		TagVarDescriptor desc = PageVariableAdatperRegistry.getInstance()
-				.getTagVarDescriptor(element);
-		if (desc == null) {
-			return null;
-		}
-		String name;
-		if (desc.isVarNameIsAttr()) {
-			name = element.getAttribute(desc.getVarName());
-			if (name == null || name.length() == 0) {
-				return null; // missing name.
-			}
-		} else {
-			name = desc.getVarName();
-		}
-		String type;
-		if (desc.isVarTypeStringIsAttr()) {
-			type = element.getAttribute(desc.getVarTypeString());
-			if (type == null || type.length() == 0) {
-				return null; // missing type
-			}
-		} else {
-			type = desc.getVarTypeString();
-		}
-		return new VariableInfo(name, desc.getVarTypeMode(), type);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.pagedesigner.jsp.core.pagevar.adapter.IPageVariableAdapter#getVariableInfos(org.w3c.dom.Element)
-	 */
-	public List getVariableInfos(Element element) {
-		IVariableInfo info = getVariableInfo(element);
-		if (info == null) {
-			return Collections.EMPTY_LIST;
-		}
-        List ret = new ArrayList(1);
-        ret.add(info);
-        return ret;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/internal/pagevar/PageVariableAdatperRegistry.java b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/internal/pagevar/PageVariableAdatperRegistry.java
deleted file mode 100644
index e64dce6..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/internal/pagevar/PageVariableAdatperRegistry.java
+++ /dev/null
@@ -1,248 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.pagedesigner.jsp.core.internal.pagevar;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import org.eclipse.core.runtime.IConfigurationElement;
-import org.eclipse.core.runtime.IExtension;
-import org.eclipse.core.runtime.IExtensionPoint;
-import org.eclipse.core.runtime.Platform;
-import org.eclipse.jst.pagedesigner.jsp.core.IJSPCoreConstants;
-import org.eclipse.jst.pagedesigner.jsp.core.JSPCorePlugin;
-import org.eclipse.jst.pagedesigner.jsp.core.pagevar.IVariableInfo;
-import org.eclipse.jst.pagedesigner.jsp.core.util.CMUtil;
-import org.eclipse.wst.xml.core.internal.contentmodel.CMElementDeclaration;
-import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
-import org.w3c.dom.Element;
-
-/**
- * @author mengbo
- * @version 1.5
- */
-public class PageVariableAdatperRegistry {
-	/**
-	 * pageVar
-	 */
-	public static final String PAGEVAR = "pageVar"; //$NON-NLS-1$
-
-	/**
-	 * taglib
-	 */
-	public static final String TAGLIB = "taglib"; //$NON-NLS-1$
-
-	/**
-	 * tag
-	 */
-	public static final String TAG = "tag"; //$NON-NLS-1$
-
-	/**
-	 * varName
-	 */
-	public static final String VARNAME = "varName"; //$NON-NLS-1$
-
-	/**
-	 * varNameIsAttr
-	 */
-	public static final String VARNAMEISATTR = "varNameIsAttr"; //$NON-NLS-1$
-
-	/**
-	 * varTypeMode
-	 */
-	public static final String VARTYPEMODE = "varTypeMode"; //$NON-NLS-1$
-
-	/**
-	 * tagName
-	 */
-	public static final String TAGNAME = "tagName"; //$NON-NLS-1$
-
-	/**
-	 * varTypeString
-	 */
-	public static final String VARTYPESTRING = "varTypeString"; //$NON-NLS-1$
-
-	/**
-	 * varTypeStringIsAttr
-	 */
-	public static final String VARTYPESTRINGISATTR = "varTypeStringIsAttr"; //$NON-NLS-1$
-
-	/**
-	 * uri
-	 */
-	public static final String URI = "uri"; //$NON-NLS-1$
-
-	private static PageVariableAdatperRegistry _instance = null;
-
-	private Map _registry;
-
-	private TagVarDescriptor _useBeanDescriptor;
-
-	/**
-	 * @return the singleton instance
-	 */
-	public static PageVariableAdatperRegistry getInstance() {
-		if (_instance == null) {
-			_instance = new PageVariableAdatperRegistry();
-		}
-		return _instance;
-	}
-
-	private PageVariableAdatperRegistry() {
-		_registry = readAllDescriptors();
-	}
-
-	// public IPageVariableAdapter createAdapter(IDOMElement ele, String uri,
-	// String tagname)
-	// {
-	// String key = uri + "#" + tagname;
-	// TagVarDescriptor desc = (TagVarDescriptor) _registry.get(key);
-	// if (desc != null)
-	// {
-	// PageVariableAdapter adapter = new PageVariableAdapter(ele);
-	// adapter.setVarName(desc.getVarName());
-	// adapter.setVarNameAttrName(desc.isVarNameIsAttr());
-	// adapter.setVarTypeString(desc.getVarTypeString());
-	// adapter.setVarTypeAttrName(desc.isVarTypeStringIsAttr());
-	// adapter.setVarTypeMode(desc.getVarTypeMode());
-	// return adapter;
-	// }
-	// else
-	// {
-	// return null;
-	// }
-	// }
-
-	private Map readAllDescriptors() {
-		Map map = new HashMap();
-
-		IExtensionPoint extensionPoint = Platform.getExtensionRegistry()
-				.getExtensionPoint(JSPCorePlugin.getPluginId(), PAGEVAR);
-		IExtension[] extensions = extensionPoint.getExtensions();
-
-		for (int i = 0; i < extensions.length; i++) {
-			IExtension ext = extensions[i];
-			IConfigurationElement[] facs = ext.getConfigurationElements();
-
-			for (int j = 0; j < facs.length; j++) {
-				if (facs[j].getName().equals(TAGLIB)) {
-					String uri = facs[j].getAttribute(URI);
-					if (uri == null || uri.length() == 0) {
-						continue;
-					}
-					IConfigurationElement[] tags = facs[j].getChildren(TAG);
-					for (int k = 0; k < tags.length; k++) {
-						TagVarDescriptor desc = new TagVarDescriptor();
-
-						String tag = tags[k].getAttribute(TAGNAME);
-						String varName = tags[k].getAttribute(VARNAME);
-						boolean varNameIsAttr = "true".equalsIgnoreCase(tags[k] //$NON-NLS-1$
-								.getAttribute(VARNAMEISATTR));
-						String varTypeString = tags[k]
-								.getAttribute(VARTYPESTRING);
-						boolean varTypeStringIsAttr = "true" //$NON-NLS-1$
-								.equalsIgnoreCase(tags[k]
-										.getAttribute(VARTYPESTRINGISATTR));
-						String varTypeModeString = tags[k]
-								.getAttribute(VARTYPEMODE);
-						int varTypeMode = toVarTypeMode(varTypeModeString);
-
-						desc.setVarName(varName);
-						desc.setVarNameIsAttr(varNameIsAttr);
-						desc.setVarTypeMode(varTypeMode);
-						desc.setVarTypeString(varTypeString);
-						desc.setVarTypeStringIsAttr(varTypeStringIsAttr);
-						desc.setTagName(tag);
-
-						// Use uri#tag as key.
-						map.put(uri + "#" + tag, desc); //$NON-NLS-1$
-					}
-				}
-			}
-		}
-
-		return map;
-	}
-
-	/**
-	 * @param varTypeModeString
-	 * @return variable typemode
-	 */
-	public static int toVarTypeMode(String varTypeModeString) {
-		if ("CLASSNAME".equalsIgnoreCase(varTypeModeString)) { //$NON-NLS-1$
-			return IVariableInfo.CLASSNAME;
-		} else if ("EXPRESSION".equalsIgnoreCase(varTypeModeString)) { //$NON-NLS-1$
-			return IVariableInfo.EXPRESSION;
-		} else if ("EXPRESSION_COLLECTION_ITEM" //$NON-NLS-1$
-				.equalsIgnoreCase(varTypeModeString)) {
-			return IVariableInfo.EXPRESSION_LISTITEM;
-		} else if ("BUNDLE".equalsIgnoreCase(varTypeModeString)) { //$NON-NLS-1$
-			return IVariableInfo.RESOURCEBUNDLE;
-		} else {
-			return IVariableInfo.EXPRESSION; // default
-		}
-	}
-
-	/**
-	 * @param uri
-	 * @param tagname
-	 * @return the tag variable descriptor for the given tag (may be null)
-	 */
-	public TagVarDescriptor getTagVarDescriptor(String uri, String tagname) {
-		String key = uri + "#" + tagname; //$NON-NLS-1$
-		return (TagVarDescriptor) _registry.get(key);
-	}
-
-	/**
-	 * @param localName
-	 * @return
-	 */
-	private TagVarDescriptor getJSPTagVarDescriptor(String localName) {
-		if (IJSPCoreConstants.TAG_USEBEAN.equals(localName)) {
-			if (_useBeanDescriptor == null) {
-				_useBeanDescriptor = new TagVarDescriptor();
-				_useBeanDescriptor.setVarName(IJSPCoreConstants.ATTR_ID);
-				_useBeanDescriptor.setVarNameIsAttr(true);
-				_useBeanDescriptor.setVarTypeMode(IVariableInfo.CLASSNAME);
-				_useBeanDescriptor
-						.setVarTypeString(IJSPCoreConstants.ATTR_CLASS);
-				_useBeanDescriptor.setVarTypeStringIsAttr(true);
-			}
-
-			return _useBeanDescriptor;
-		}
-
-		return null;
-	}
-
-	/**
-	 * @param target 
-	 * @return the tag variable descriptor for the target
-	 */
-	public TagVarDescriptor getTagVarDescriptor(Element target) {
-		if (target instanceof IDOMElement) {
-			IDOMElement xmlEle = (IDOMElement) target;
-			CMElementDeclaration decl = CMUtil.getElementDeclaration(xmlEle);
-			if (decl != null) {
-			    if (CMUtil.isJSP(decl)) {
-			        return getJSPTagVarDescriptor(xmlEle.getLocalName());
-			    }
-                String uri = CMUtil.getTagURI(decl);
-                if (uri != null) {
-                    return getTagVarDescriptor(uri, xmlEle.getLocalName());
-                }
-			}
-		}
-        return null;
-	}
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/internal/pagevar/TagVarDescriptor.java b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/internal/pagevar/TagVarDescriptor.java
deleted file mode 100644
index 8e5b649..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/internal/pagevar/TagVarDescriptor.java
+++ /dev/null
@@ -1,114 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.pagedesigner.jsp.core.internal.pagevar;
-
-/**
- * @author mengbo
- * @version 1.5
- */
-public class TagVarDescriptor {
-	private String _varName;
-
-	private boolean _varNameIsAttr;
-
-	private String _varTypeString;
-
-	private boolean _varTypeStringIsAttr;
-
-	private int _varTypeMode;
-
-	private String _tagName;
-
-	/**
-	 * @return the varName
-	 */
-	public String getVarName() {
-		return _varName;
-	}
-
-	/**
-	 * @param varName
-	 */
-	public void setVarName(String varName) {
-		this._varName = varName;
-	}
-
-	/**
-	 * @return true if var name is attribute
-	 */
-	public boolean isVarNameIsAttr() {
-		return _varNameIsAttr;
-	}
-
-	/**
-	 * @param varNameIsAttr
-	 */
-	public void setVarNameIsAttr(boolean varNameIsAttr) {
-		this._varNameIsAttr = varNameIsAttr;
-	}
-
-	/**
-	 * @return the variable type mode
-	 */
-	public int getVarTypeMode() {
-		return _varTypeMode;
-	}
-
-	/**
-	 * @param varTypeMode
-	 */
-	public void setVarTypeMode(int varTypeMode) {
-		this._varTypeMode = varTypeMode;
-	}
-
-	/**
-	 * @return the variable type string
-	 */
-	public String getVarTypeString() {
-		return _varTypeString;
-	}
-
-	/**
-	 * @param varTypeString
-	 */
-	public void setVarTypeString(String varTypeString) {
-		this._varTypeString = varTypeString;
-	}
-
-	/**
-	 * @return true if variable type string is attr
-	 */
-	public boolean isVarTypeStringIsAttr() {
-		return _varTypeStringIsAttr;
-	}
-
-	/**
-	 * @param varTypeStringIsAttr
-	 */
-	public void setVarTypeStringIsAttr(boolean varTypeStringIsAttr) {
-		this._varTypeStringIsAttr = varTypeStringIsAttr;
-	}
-
-	/**
-	 * @param tag
-	 */
-	public void setTagName(String tag) {
-		this._tagName = tag;
-	}
-
-	/**
-	 * @return the tag name
-	 */
-	public String getTagName() {
-		return this._tagName;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/internal/pagevar/VariableInfo.java b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/internal/pagevar/VariableInfo.java
deleted file mode 100644
index 6b29b9a..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/internal/pagevar/VariableInfo.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.pagedesigner.jsp.core.internal.pagevar;
-
-import org.eclipse.jst.pagedesigner.jsp.core.pagevar.IVariableInfo;
-
-/**
- * @author mengbo
- * @version 1.5
- */
-public class VariableInfo implements IVariableInfo {
-	private String _typeInfo;
-
-	private int _mode;
-
-	private String _name;
-
-	/**
-	 * @param name 
-	 * @param mode 
-	 * @param typeInfo 
-	 * 
-	 */
-	public VariableInfo(String name, int mode, String typeInfo) {
-		this._name = name;
-		this._mode = mode;
-		this._typeInfo = typeInfo;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.pagedesigner.jsp.core.pagevar.IVariableInfo#getName()
-	 */
-	public String getName() {
-		return _name;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.pagedesigner.jsp.core.pagevar.IVariableInfo#getMode()
-	 */
-	public int getMode() {
-		return _mode;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.eclipse.jst.pagedesigner.jsp.core.pagevar.IVariableInfo#getTypeInfoString()
-	 */
-	public String getTypeInfoString() {
-		return _typeInfo;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see java.lang.Object#equals(java.lang.Object)
-	 */
-    // TODO: no hashcode override?
-	public boolean equals(Object obj) {
-		if (this == obj) {
-			return true;
-		}
-		if (obj instanceof VariableInfo) {
-			VariableInfo info = (VariableInfo) obj;
-			return this._mode == info._mode && equals(this._name, info._name)
-					&& equals(this._typeInfo, info._typeInfo);
-		}
-        return false;
-	}
-
-	private boolean equals(String s1, String s2) {
-		if (s1 == null) {
-			return s2 == null;
-		}
-        return s1.equals(s2);
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/pagevar/IChangeListener.java b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/pagevar/IChangeListener.java
deleted file mode 100644
index 9196d0c..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/pagevar/IChangeListener.java
+++ /dev/null
@@ -1,25 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.pagedesigner.jsp.core.pagevar;
-
-import java.util.EventListener;
-
-/**
- * @author mengbo
- * @version 1.5
- */
-public interface IChangeListener extends EventListener {
-	/**
-	 * fire a changed indication
-	 */
-	public void changed();
-}
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/pagevar/IPageVariablesProvider.java b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/pagevar/IPageVariablesProvider.java
deleted file mode 100644
index a538ec8..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/pagevar/IPageVariablesProvider.java
+++ /dev/null
@@ -1,38 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.pagedesigner.jsp.core.pagevar;
-
-/**
- * @author mengbo
- * @version 1.5
- */
-public interface IPageVariablesProvider {
-	/**
-	 * 
-	 */
-	public void refresh();
-
-	/**
-	 * @return the bean infos
-	 */
-	public IVariableInfo[] getBeanInfos();
-
-	/**
-	 * @param listener
-	 */
-	public void addChangeListener(IChangeListener listener);
-
-	/**
-	 * @param listener
-	 */
-	public void removeChangeListener(IChangeListener listener);
-}
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/pagevar/IVariableInfo.java b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/pagevar/IVariableInfo.java
deleted file mode 100644
index a491de0..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/pagevar/IVariableInfo.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.pagedesigner.jsp.core.pagevar;
-
-/**
- * @author mengbo
- * @version 1.5
- */
-public interface IVariableInfo {
-	/**
-	 * @return the name
-	 */
-	public String getName();
-
-	/**
-	 * TODO
-	 */
-	public static final int CLASSNAME = 0;
-
-	/**
-	 * TODO
-	 */
-	public static final int EXPRESSION = 1;
-
-	/**
-	 * TODO
-	 */
-	public static final int EXPRESSION_LISTITEM = 2;
-
-	/**
-	 * TODO
-	 */
-	public static final int RESOURCEBUNDLE = 3;
-
-	/**
-	 * @return one of CLASSNAME, EXPRESSION, EXPRESSION_LISTITEM, RESOURCEBUNDLE
-	 */
-	public int getMode();
-
-	/**
-	 * type info string will have different meaning for different mode.
-	 * 
-	 * @return the type info string
-	 */
-	public String getTypeInfoString();
-
-}
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/pagevar/adapter/IDocumentPageVariableAdapter.java b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/pagevar/adapter/IDocumentPageVariableAdapter.java
deleted file mode 100644
index 31979ef..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/pagevar/adapter/IDocumentPageVariableAdapter.java
+++ /dev/null
@@ -1,26 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.pagedesigner.jsp.core.pagevar.adapter;
-
-import org.eclipse.jst.pagedesigner.jsp.core.pagevar.IPageVariablesProvider;
-import org.eclipse.wst.sse.core.internal.provisional.INodeAdapter;
-
-/**
- * IDocumentPageVariableAdapter will be adapted to the jsp document.
- * 
- * @author mengbo
- * @version 1.5
- */
-public interface IDocumentPageVariableAdapter extends IPageVariablesProvider,
-		INodeAdapter {
-    // TODO: what's this for?
-}
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/pagevar/adapter/IPageVariableAdapter.java b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/pagevar/adapter/IPageVariableAdapter.java
deleted file mode 100644
index 158799f..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/pagevar/adapter/IPageVariableAdapter.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.pagedesigner.jsp.core.pagevar.adapter;
-
-import java.util.List;
-
-import org.eclipse.jst.pagedesigner.jsp.core.pagevar.IVariableInfo;
-import org.eclipse.wst.sse.core.internal.provisional.INodeAdapter;
-import org.w3c.dom.Element;
-
-/**
- * A IPageVariableAdapter normally will be adapted to an JSP tag.
- * 
- * @author mengbo
- * @version 1.5
- */
-public interface IPageVariableAdapter extends INodeAdapter {
-	/**
-	 * most JSP tags will only support a single variable.
-	 * @param element 
-	 * 
-	 * @return true if the tag supports multiple variables
-	 */
-	public boolean supportMultipleVariable(Element element);
-
-	/**
-	 * If only support single variable, this method will return the variable
-	 * info. This method is provided for better performance.
-	 * 
-	 * @param element 
-	 * @return null means no variable info provided.
-	 */
-	public IVariableInfo getVariableInfo(Element element);
-
-	/**
-	 * should return a list of IVariableInfo
-	 * @param element 
-	 * 
-	 * @return the list of variable infos
-	 */
-	public List getVariableInfos(Element element);
-}
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/pagevar/adapter/PageVariableAdapterFactory.java b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/pagevar/adapter/PageVariableAdapterFactory.java
deleted file mode 100644
index 1c6c64d..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/pagevar/adapter/PageVariableAdapterFactory.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.pagedesigner.jsp.core.pagevar.adapter;
-
-import org.eclipse.jst.pagedesigner.jsp.core.internal.pagevar.PageVariableAdapter;
-import org.eclipse.wst.sse.core.internal.provisional.AbstractAdapterFactory;
-import org.eclipse.wst.sse.core.internal.provisional.INodeAdapter;
-import org.eclipse.wst.sse.core.internal.provisional.INodeNotifier;
-import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
-
-/**
- * @author mengbo
- * @version 1.5
- */
-public class PageVariableAdapterFactory extends AbstractAdapterFactory {
-	/**
-	 * 
-	 */
-	public PageVariableAdapterFactory() {
-		super(IPageVariableAdapter.class, true);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @seeorg.eclipse.wst.sse.core.internal.provisional.AbstractAdapterFactory#createAdapter(org.eclipse.wst.sse.core.internal.provisional.INodeNotifier)
-	 */
-	protected INodeAdapter createAdapter(INodeNotifier target) {
-		if (target instanceof IDOMElement) {
-			return PageVariableAdapter.getInstance();
-		}
-        return null;
-	}
-}
diff --git a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/util/CMUtil.java b/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/util/CMUtil.java
deleted file mode 100644
index fd299aa..0000000
--- a/jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/util/CMUtil.java
+++ /dev/null
@@ -1,97 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006 Sybase, Inc. and others.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Sybase, Inc. - initial API and implementation
- *******************************************************************************/
-package org.eclipse.jst.pagedesigner.jsp.core.util;
-
-import org.eclipse.jst.jsp.core.internal.contentmodel.tld.provisional.TLDDocument;
-import org.eclipse.jst.jsp.core.internal.contentmodel.tld.provisional.TLDElementDeclaration;
-import org.eclipse.wst.html.core.internal.provisional.HTMLCMProperties;
-import org.eclipse.wst.sse.core.internal.provisional.INodeNotifier;
-import org.eclipse.wst.xml.core.internal.contentmodel.CMDocument;
-import org.eclipse.wst.xml.core.internal.contentmodel.CMElementDeclaration;
-import org.eclipse.wst.xml.core.internal.contentmodel.CMNode;
-import org.eclipse.wst.xml.core.internal.provisional.contentmodel.CMNodeWrapper;
-import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
-import org.eclipse.wst.xml.core.internal.ssemodelquery.ModelQueryAdapter;
-
-/**
- * Utility class to content model related information.
- * 
- * @author mengbo
- */
-public class CMUtil {
-	/**
-	 * If the element is a custom tag, get the URI of it. If the element is a
-	 * standard JSP tag, return null. If is not jsp tag, then return null
-	 * @param decl 
-	 * @return the tag uri for decl
-	 */
-	public static String getTagURI(CMElementDeclaration decl) {
-		if (decl instanceof CMNodeWrapper) {
-			decl = (CMElementDeclaration) ((CMNodeWrapper) decl)
-					.getOriginNode();
-		}
-		if (decl instanceof TLDElementDeclaration) {
-			CMDocument doc = ((TLDElementDeclaration) decl).getOwnerDocument();
-			if (doc instanceof TLDDocument) {
-				return ((TLDDocument) doc).getUri();
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * get element declaration of specified element
-	 * 
-	 * @param element
-	 * @return null if can't get it.
-	 */
-	public static CMElementDeclaration getElementDeclaration(IDOMElement element) {
-		INodeNotifier notifier = (INodeNotifier) element.getOwnerDocument();
-		if (notifier == null) {
-			return null;
-		}
-		ModelQueryAdapter mqa = (ModelQueryAdapter) notifier
-				.getAdapterFor(ModelQueryAdapter.class);
-		if (mqa == null) {
-			return null;
-		}
-		return mqa.getModelQuery().getCMElementDeclaration(element);
-	}
-
-	/**
-	 * @param element
-	 * @return the tld element declaration for element
-	 */
-	public static TLDElementDeclaration getTLDElementDeclaration(
-			IDOMElement element) {
-		CMNode decl = getElementDeclaration(element);
-		if (decl instanceof CMNodeWrapper) {
-			decl = ((CMNodeWrapper) decl).getOriginNode();
-		}
-		if (decl instanceof TLDElementDeclaration) {
-			return (TLDElementDeclaration) decl;
-		}
-        return null;
-	}
-
-	/**
-	 * @param decl 
-	 * @return true if decl is a JSP tag 
-	 */
-	public static boolean isJSP(CMElementDeclaration decl) {
-		if (!decl.supports(HTMLCMProperties.IS_JSP)) {
-			return false;
-		}
-		return ((Boolean) decl.getProperty(HTMLCMProperties.IS_JSP))
-				.booleanValue();
-	}
-}
